Package xformslib :: Module library
[hide private]
[frames] | no frames]

Source Code for Module xformslib.library

    1  #!/usr/bin/env python 
    2  # -*- coding: iso8859-1 -*- 
    3   
    4  """ 
    5      xforms-python 
    6      Python wrapper for XForms (X11) GUI C toolkit library using ctypes 
    7   
    8      Copyright (C) 2009  Luca Lazzaroni "LukenShiro"  <lukenshiro@ngi.it> 
    9   
   10      This program is free software: you can redistribute it and/or modify 
   11      it under the terms of the GNU Lesser General Public License as 
   12      published by the Free Software Foundation, version 2.1 of the License. 
   13   
   14      This program is distributed in the hope that it will be useful, 
   15      but WITHOUT ANY WARRANTY; without even the implied warranty of 
   16      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
   17      GNU Lesser General Public License for more details. 
   18   
   19      You should have received a copy of the GNU LGPL along with this 
   20      program. If not, see <http://www.gnu.org/licenses/>. 
   21   
   22      See CREDITS file to read acknowledgements and thanks to XForms, 
   23      ctypes and other developers. 
   24  """ 
   25   
   26  # originally generated by 'h2xml+gccxml' and 'xml2py' 
   27  # then heavily reordered and reworked 
   28   
   29  # ############################################# # 
   30  # Interface to XForms shared object libraries   # 
   31  # ############################################# # 
   32   
   33  import ctypes as cty 
   34  import ctypes.util as ctyutil 
   35  import sys 
   36  import warnings 
   37  from xfdata import *       # data types and constants from XForms 
   38   
   39   
   40  # xforms-python version 
   41  __mainversion__ = "0.3.1"               # real version 
   42  __vers_against_xforms__ = "1.0.93pre2"   # xforms version to be built against 
   43  __version__ = __mainversion__+"_"+__vers_against_xforms__ 
   44   
   45   
   46  header_filename = "/usr/include/forms.h" 
   47   
   48   
49 -def get_xforms_version():
50 """ Return version string of installed XForms library/header 51 """ 52 53 complete_xf_version = "" 54 try: 55 formsh = open(header_filename, "r") 56 except IOError: 57 raise XFormsLoadError("XForms library toolkit header is not " \ 58 " installed properly") 59 else: 60 try: 61 # a reasonable size to catch version values 62 fconten = formsh.read(2500) 63 except IOError: 64 raise XFormsLoadError("XForms library toolkit header is not " \ 65 "installed properly") 66 else: 67 formsh.close() 68 listconten = fconten.split("\n") 69 for singline in listconten: 70 idx_ver = singline.find("FL_VERSION") 71 if idx_ver != -1: 72 strg_ver1 = singline[idx_ver:len(singline)] 73 strg_ver = strg_ver1.replace("FL_VERSION", "").strip(" ") 74 break 75 for singline in listconten: 76 idx_rev = singline.find("FL_REVISION") 77 if idx_rev != -1: 78 strg_rev1 = singline[idx_rev:len(singline)] 79 strg_rev = strg_rev1.replace("FL_REVISION", "").strip(" ") 80 break 81 for singline in listconten: 82 idx_fix = singline.find("FL_FIXLEVEL") 83 if idx_fix != -1: 84 strg_fix1 = singline[idx_fix:len(singline)] 85 strg_fix = strg_fix1.replace("FL_FIXLEVEL", \ 86 "").strip(" ").strip('"') 87 break 88 complete_xf_version = strg_ver+"."+strg_rev+"."+strg_fix 89 90 return complete_xf_version
91 92
93 -def verify_version_compatibility():
94 """ verify compatibility between xforms-python version and XForms version 95 """ 96 97 xforms_vers = get_xforms_version() 98 if __vers_against_xforms__ != xforms_vers: # no match 99 warningmsg = "xforms-python is implemented against XForms version " \ 100 " %s and does not match XForms installed version " \ 101 "(%s). Some compatibility problems may arise if XForms" \ 102 " public interface has been modified." % \ 103 (__vers_against_xforms__, xforms_vers) 104 warnings.warn(warningmsg, UserWarning)
105 106
107 -class XFormsLoadError(OSError):
108 """ Error in loading shared object library """ 109 110 pass
111 112
113 -class XFormsTypeError(TypeError):
114 """ Generic error for type mismatch """ 115 116 pass
117 118
119 -def warn_deprecated_function(altfunc=""):
120 """ Warns the user when a function is deprecated and should not be used 121 anymore. If a param is provided it may advide the user about an 122 alternative function. 123 """ 124 125 funcname = sys._getframe(1).f_code.co_name 126 if altfunc: 127 newaltfunc = "Use %s instead." % altfunc 128 else: 129 newaltfunc = "" 130 warningmsg = "Function %s is deprecated and might be removed in future" \ 131 " releases. %s" % (funcname, newaltfunc) 132 warnings.warn(warningmsg, DeprecationWarning, 3)
133 134
135 -def func_do_nothing_placeholder(cfunction):
136 """ Print a warning if called function doesn't exist 137 """ 138 139 warningmsg = "C function %s does NOT exist, hence its call is ignored," \ 140 " hence it is not wrappable and callable in python, as " \ 141 "well. Maybe removed or disabled?" % cfunction 142 warnings.warn(warningmsg, UserWarning) 143 return None
144 145 146 # placeholders to keep reference to c functions 147 # keeps global to avoid garbage collector's' unpredictable behaviour 148 _cfunc_refs = [] 149 # just in case, maintains elements used as parameters, too 150 _elem_refs = [] 151 152
153 -def keep_cfunc_refs(*cfunclist):
154 """ Adds a reference for _cfunc_refs list of values 155 """ 156 157 for singvalue in cfunclist: 158 _cfunc_refs.append(singvalue)
159 160
161 -def keep_elem_refs(*elemlist):
162 """ Adds a reference for _elem_refs list of values 163 """ 164 165 for singvalue in elemlist: 166 _elem_refs.append(singvalue)
167 168 169 loaded_xlibraries = {'libforms' : None, 'libflimage' : None, \ 170 'libformsgl' : None, 'libx11' : None} 171 172
173 -def load_so_libforms():
174 """ Load libforms.so else raise an error -> library instance 175 """ 176 177 if loaded_xlibraries['libforms'] is None: 178 libfbase = ctyutil.find_library("forms") 179 if not libfbase: # not installed 180 raise XFormsLoadError("XForms library toolkit is not installed" \ 181 " properly") 182 else: 183 loaded_xlibraries['libforms'] = cty.cdll.LoadLibrary(libfbase) 184 return loaded_xlibraries['libforms']
185 186
187 -def load_so_libflimage():
188 """ Load libflimage.so else raise an error -> library instance 189 """ 190 191 if loaded_xlibraries['libflimage'] is None: 192 libfimg = ctyutil.find_library("flimage") 193 if not libfimg: # not installed 194 raise XFormsLoadError("XForms library toolkit is not installed" \ 195 " properly") 196 else: 197 loaded_xlibraries['libflimage'] = cty.cdll.LoadLibrary(libfimg) 198 return loaded_xlibraries['libflimage']
199 200
201 -def load_so_libformsgl():
202 """ Load libformsGL.so else raise an error -> library instance 203 """ 204 205 if loaded_xlibraries['libformsgl'] is None: 206 libfgl = ctyutil.find_library("formsGL") 207 if not libfgl: # not installed 208 raise XFormsLoadError("XForms library toolkit is not installed" \ 209 " properly, with OpenGL support") 210 else: 211 loaded_xlibraries['libformsgl'] = cty.cdll.LoadLibrary(libfgl) 212 return loaded_xlibraries['libformsgl']
213 214
215 -def load_so_libx11():
216 """ Load libX11.so.6 else raise an error -> library instance 217 """ 218 219 if loaded_xlibraries['libx11'] is None: 220 libx11 = ctyutil.find_library("X11") 221 if not libx11: # not installed 222 raise XFormsLoadError("X11 libraries are not installed" \ 223 " properly") 224 else: 225 loaded_xlibraries['libx11'] = cty.cdll.LoadLibrary(libx11) 226 return loaded_xlibraries['libx11']
227 228
229 -def cfuncproto(library, cfuncname, retval, arglist, doc=""):
230 """ Prototype for C function to be wrapped in python 231 """ 232 233 loadedfunc = None 234 try: 235 loadedfunc = getattr(library, cfuncname) 236 except AttributeError: 237 # function doesn't exist 238 loadedfunc = func_do_nothing_placeholder(cfuncname) 239 else: 240 loadedfunc.restype = retval 241 loadedfunc.argtypes = arglist 242 loadedfunc.__doc__ = doc 243 244 return loadedfunc
245 246 247 # functions to convert a parameter into a python type then into the 248 # equivalent ctypes type 249
250 -def convert_to_string(paramname):
251 """ Converts paramname to python str and to ctypes c_char_p """ 252 253 try: 254 retv0 = str(paramname) 255 except ValueError: 256 raise XFormsTypeError("Parameter cannot be converted into" \ 257 "'str'/'c_char_p'") 258 retv = cty.c_char_p(retv0) 259 #print "string", paramname, retv0, retv 260 return retv
261 262
263 -def convert_to_int(paramname):
264 """ Converts paramname to python int and to ctypes c_int """ 265 266 if not isinstance(paramname, cty.c_int): 267 try: 268 retv0 = int(paramname) 269 except ValueError: 270 raise XFormsTypeError("Parameter cannot be converted into" \ 271 " 'int'/'c_int'") 272 retv = cty.c_int(retv0) 273 #print "int", paramname, retv0, retv 274 return retv 275 else: 276 return paramname
277 278 convert_to_FL_Coord = convert_to_int 279 280
281 -def convert_to_uint(paramname):
282 """ Converts paramname to python int and to ctypes c_uint """ 283 284 if not isinstance(paramname, cty.c_int): 285 try: 286 retv0 = int(paramname) 287 except ValueError: 288 raise XFormsTypeError("Parameter cannot be converted into" \ 289 " 'int'/'c_uint'") 290 else: 291 retv = cty.c_uint(retv0) 292 #print "uint", paramname, retv0, retv 293 return retv 294 else: 295 return paramname
296 297
298 -def convert_to_long(paramname):
299 """ Converts paramname to python long and to ctypes c_long """ 300 301 if not isinstance(paramname, cty.c_long): 302 try: 303 retv0 = long(paramname) 304 except ValueError: 305 raise XFormsTypeError("Parameter cannot be converted into" \ 306 " 'long'/'c_long'") 307 else: 308 retv = cty.c_long(retv0) 309 #print "long", paramname, retv0, retv 310 return retv 311 else: 312 return paramname
313 314
315 -def convert_to_ulong(paramname):
316 """ Converts paramname to python long and to ctypes c_ulong """ 317 318 if not isinstance(paramname, cty.c_ulong): 319 try: 320 retv0 = long(paramname) 321 except ValueError: 322 raise XFormsTypeError("Parameter cannot be converted into" \ 323 " 'long'/'c_ulong'") 324 else: 325 retv = cty.c_ulong(retv0) 326 #print "ulong", paramname, retv0, retv 327 return retv 328 else: 329 return paramname
330 331 332 convert_to_FL_COLOR = convert_to_ulong 333 convert_to_Window = convert_to_ulong 334 convert_to_Pixmap = convert_to_ulong 335 336
337 -def convert_to_double(paramname):
338 """ Converts paramname to python float and to ctypes c_double """ 339 340 if not isinstance(paramname, cty.c_double): 341 try: 342 retv0 = float(paramname) 343 except ValueError: 344 raise XFormsTypeError("Parameter cannot be converted into" \ 345 " 'float'/'c_double'") 346 else: 347 retv = cty.c_double(retv0) 348 #print "double", paramname, retv0, retv 349 return retv 350 else: 351 return paramname
352 353
354 -def convert_to_float(paramname):
355 """ Converts paramname to python float and to ctypes c_float """ 356 357 if not isinstance(paramname, cty.c_float): 358 try: 359 retv0 = float(paramname) 360 except ValueError: 361 raise XFormsTypeError("Parameter cannot be converted into" \ 362 " 'float'/'c_float'") 363 else: 364 retv = cty.c_float(retv0) 365 #print "float", paramname, retv0, retv 366 return retv 367 else: 368 return paramname
369 370
371 -def convert_to_ubyte(paramname):
372 """ Converts paramname to ctypes c_ubyte """ 373 374 retv = cty.c_ubyte(paramname) 375 return retv
376 377
378 -def make_int_and_pointer():
379 """ Makes a ctypes c_int and its pointer, and returns both """ 380 381 baseval = cty.c_int() 382 ptrbaseval = cty.byref(baseval) 383 return baseval, ptrbaseval
384 385 make_FL_Coord_and_pointer = make_int_and_pointer 386 387
388 -def make_uint_and_pointer():
389 """ Makes a ctypes c_uint and its pointer, and returns both """ 390 391 baseval = cty.c_uint() 392 ptrbaseval = cty.byref(baseval) 393 return baseval, ptrbaseval
394 395
396 -def make_long_and_pointer():
397 """ Makes a ctypes c_long and its pointer, and returns both """ 398 399 baseval = cty.c_long() 400 ptrbaseval = cty.byref(baseval) 401 return baseval, ptrbaseval
402 403
404 -def make_ulong_and_pointer():
405 """ Makes a ctypes c_ulong and its pointer, and returns both """ 406 407 baseval = cty.c_ulong() 408 ptrbaseval = cty.byref(baseval) 409 return baseval, ptrbaseval
410 411 make_Pixmap_and_pointer = make_ulong_and_pointer 412 make_FL_COLOR_and_pointer = make_ulong_and_pointer 413 414
415 -def make_float_and_pointer():
416 """ Makes a ctypes c_float and its pointer, and returns both """ 417 418 baseval = cty.c_float() 419 ptrbaseval = cty.byref(baseval) 420 return baseval, ptrbaseval
421 422
423 -def make_double_and_pointer():
424 """ Makes a ctypes c_double and its pointer, and returns both """ 425 426 baseval = cty.c_double() 427 ptrbaseval = cty.byref(baseval) 428 return baseval, ptrbaseval
429 430
431 -def check_admitted_listvalues(paramname, *valueslist):
432 """ Check if paramname value is valid in accordance to a list 433 of admissible values. 434 """ 435 436 if isinstance(valueslist, list): 437 if paramname not in valueslist: 438 raise XFormsTypeError("Parameter value must be included in " \ 439 "list %s." % valueslist)
440 441 442 # exported variables 443 FL_EVENT = (cty.POINTER(FL_OBJECT)).in_dll(load_so_libforms(), 'FL_EVENT') 444 fl_current_form = (cty.POINTER(FL_FORM)).in_dll(load_so_libforms(), \ 445 'fl_current_form') 446 fl_display = (cty.POINTER(Display)).in_dll(load_so_libforms(), 'fl_display') 447 fl_screen = (cty.c_int).in_dll(load_so_libforms(), 'fl_screen') 448 # root window 449 fl_root = (Window).in_dll(load_so_libforms(), 'fl_root') 450 # virtual root window 451 fl_vroot = (Window).in_dll(load_so_libforms(), 'fl_vroot') 452 # screen dimension in pixels 453 fl_scrh = (cty.c_int).in_dll(load_so_libforms(), 'fl_scrh') 454 fl_scrw = (cty.c_int).in_dll(load_so_libforms(), 'fl_scrw') 455 fl_vmode = (cty.c_int).in_dll(load_so_libforms(), 'fl_vmode') 456 fl_state = (cty.POINTER(FL_State)).in_dll(load_so_libforms(), 'fl_state') 457 fl_ul_magic_char = (STRING).in_dll(load_so_libforms(), 'fl_state') 458 459 460 ######################################## 461 # forms.h (Basic.h) 462 # Basic definitions and limits. 463 # Window system independent prototypes 464 # Modify with care 465 ######################################## 466 467
468 -def FL_IS_UPBOX(t):
469 if (t == FL_UP_BOX) or \ 470 (t == FL_OVAL3D_UPBOX) or \ 471 (t == FL_ROUNDED3D_UPBOX): 472 return True 473 else: 474 return False
475 476
477 -def FL_IS_DOWNBOX(t):
478 if (t == FL_DOWN_BOX) or \ 479 (t == FL_OVAL3D_DOWNBOX) or \ 480 (t == FL_ROUNDED3D_DOWNBOX): 481 return True 482 else: 483 return False
484 485
486 -def FL_TO_DOWNBOX(t):
487 if t == FL_UP_BOX: 488 t1 = FL_DOWN_BOX 489 elif t == FL_ROUNDED3D_UPBOX: 490 t1 = FL_ROUNDED3D_DOWNBOX 491 elif t == FL_OVAL3D_UPBOX: 492 t1 = FL_OVAL3D_DOWNBOX 493 else: 494 t1 = t 495 return t1
496 497
498 -def special_style(a):
499 if (a >= FL_SHADOW_STYLE) and \ 500 (a <= (FL_EMBOSSED_STYLE + FL_MAXFONTS)): 501 return True 502 else: 503 return False
504 505 506 507 508 # Macro for getting at the object handlers return value 509
510 -def fl_object_returned(pObject):
511 return pObject.contents.returned
512 513 514 # IO other than XEvent Q 515 516 FL_IO_CALLBACK = cty.CFUNCTYPE(None, cty.c_int, cty.c_void_p) 517
518 -def fl_add_io_callback(fd, mask, py_IoCallback, data):
519 """ 520 fl_add_io_callback(fd, mask, py_IoCallback, data) 521 522 Registers an input callback function when input is available from fd. 523 524 @param fd : a valid file descriptor in a *nix system 525 @param mask : under what circumstance the input callback should be 526 invoked (i.e. FL_READ, FL_WRITE or FL_EXCEPT) 527 @param py_IoCallback : python function to be invoked under mask 528 condition, fn(num, ptr_void) 529 @param data : argument to be passed to function 530 """ 531 532 _fl_add_io_callback = cfuncproto( 533 load_so_libforms(), "fl_add_io_callback", \ 534 None, [cty.c_int, cty.c_uint, FL_IO_CALLBACK, cty.c_void_p], \ 535 """void fl_add_io_callback(int fd, unsigned int mask, 536 FL_IO_CALLBACK callback, void * data) 537 """) 538 ifd = convert_to_int(fd) 539 uimask = convert_to_uint(mask) 540 c_IoCallback = FL_IO_CALLBACK(py_IoCallback) 541 pdata = cty.cast(data, cty.c_void_p) 542 keep_cfunc_refs(c_IoCallback, py_IoCallback) 543 keep_elem_refs(fd, ifd, mask, uimask, data, pdata) 544 _fl_add_io_callback(ifd, uimask, c_IoCallback, pdata)
545 546
547 -def fl_remove_io_callback(fd, mask, py_IoCallback):
548 """ 549 fl_remove_io_callback(fd, mask, py_IoCallback) 550 551 Removes the registered callback function when input is available 552 from fd. 553 554 @param fd : a valid file descriptor in a unix system 555 @param mask : under what circumstance the input callback should be 556 removed (i.e. xfc.FL_READ, xfc.FL_WRITE, xfc.FL_EXCEPT) 557 @param py_IoCallback : python function to be removed under mask 558 condition, fn(num, ptr_void) 559 """ 560 561 _fl_remove_io_callback = cfuncproto( 562 load_so_libforms(), "fl_remove_io_callback", \ 563 None, [cty.c_int, cty.c_uint, FL_IO_CALLBACK], \ 564 """void fl_remove_io_callback(int fd, unsigned int mask, 565 FL_IO_CALLBACK cb) 566 """) 567 check_admitted_listvalues(mask, ASYNCIO_list) 568 ifd = convert_to_int(fd) 569 uimask = convert_to_uint(mask) 570 c_IoCallback = FL_IO_CALLBACK(py_IoCallback) 571 keep_cfunc_refs(c_IoCallback, py_IoCallback) 572 keep_elem_refs(fd, ifd, mask, uimask) 573 _fl_remove_io_callback(ifd, uimask, c_IoCallback)
574 575 576 # signals 577 578 FL_SIGNAL_HANDLER = cty.CFUNCTYPE(None, cty.c_int, cty.c_void_p) 579
580 -def fl_add_signal_callback(sglnum, py_SignalHandler, data):
581 """ 582 fl_add_signal_callback(sglnum, py_SignalHandler, data) 583 584 Handles the receipt of a signal by registering a callback function 585 that gets called when a signal is caught (only 1 function per signal) 586 587 @param sglnum : signal number (e.g. SIGALRM, SIGINT, etc.) 588 @param py_SignalHandler : python function to be invoked after 589 catching the signal, fn(num, ptr_void) 590 @param data : argument to be passed to function 591 """ 592 593 _fl_add_signal_callback = cfuncproto( 594 load_so_libforms(), "fl_add_signal_callback", \ 595 None, [cty.c_int, FL_SIGNAL_HANDLER, cty.c_void_p], \ 596 """void fl_add_signal_callback(int s, FL_SIGNAL_HANDLER cb, 597 void * data) 598 """) 599 isglnum = convert_to_int(sglnum) 600 c_SignalHandler = FL_SIGNAL_HANDLER(py_SignalHandler) 601 pdata = cty.cast(data, cty.c_void_p) 602 keep_cfunc_refs(c_SignalHandler, py_SignalHandler) 603 keep_elem_refs(sglnum, isglnum, data, pdata) 604 _fl_add_signal_callback(isglnum, c_SignalHandler, pdata)
605 606
607 -def fl_remove_signal_callback(sglnum):
608 """ 609 fl_remove_signal_callback(sglnum) 610 611 Removes a previously registered callback function related to a signal. 612 613 @param sglnum : signal number (e.g. SIGALRM, SIGINT, etc.) 614 """ 615 616 _fl_remove_signal_callback = cfuncproto( 617 load_so_libforms(), "fl_remove_signal_callback", \ 618 None, [cty.c_int], \ 619 """void fl_remove_signal_callback(int s) 620 """) 621 isglnum = convert_to_int(sglnum) 622 keep_elem_refs(sglnum, isglnum) 623 _fl_remove_signal_callback(isglnum)
624 625
626 -def fl_signal_caught(sglnum):
627 """ 628 fl_signal_caught(sglnum) 629 630 Informs the main loop of the delivery of the signal signum, the signal 631 is received by the application program 632 633 @param sglnum : signal number (e.g. SIGALRM, SIGINT, etc.) 634 """ 635 636 _fl_signal_caught = cfuncproto( 637 load_so_libforms(), "fl_signal_caught", \ 638 None, [cty.c_int], \ 639 """void fl_signal_caught(int s) 640 """) 641 isglnum = convert_to_int(sglnum) 642 keep_elem_refs(sglnum, isglnum) 643 _fl_signal_caught(isglnum)
644 645
646 -def fl_app_signal_direct(flag):
647 """ 648 fl_app_signal_direct(flag) 649 650 Changes the default behavior of the built-in signal facilities (to 651 be called with a true value for flag prior to any use of 652 fl_add_signal_callback 653 654 @param flag : flag (0|1) 655 """ 656 657 _fl_app_signal_direct = cfuncproto( 658 load_so_libforms(), "fl_app_signal_direct", \ 659 None, [cty.c_int], \ 660 """void fl_app_signal_direct(int y) 661 """) 662 iflag = convert_to_int(flag) 663 keep_elem_refs(flag, iflag) 664 _fl_app_signal_direct(iflag)
665 666 667 # timeouts 668 669 FL_TIMEOUT_CALLBACK = cty.CFUNCTYPE(None, cty.c_int, cty.c_void_p) 670
671 -def fl_add_timeout(msec, py_TimeoutCallback, data):
672 """ 673 fl_add_timeout(msec, py_TimeoutCallback, data) -> timer ID 674 675 Adds a timeout callback after a specified elapsed time. 676 677 @param msec : time elapsed in milliseconds 678 @param py_TimeoutCallback : python function to be invoked after time, 679 fn(num, ptr_void) 680 @param data : argument to be passed to function 681 """ 682 683 _fl_add_timeout = cfuncproto( 684 load_so_libforms(), "fl_add_timeout", \ 685 cty.c_int, [cty.c_long, FL_TIMEOUT_CALLBACK, cty.c_void_p], \ 686 """int fl_add_timeout(long int msec, 687 FL_TIMEOUT_CALLBACK callback, void * data) 688 """) 689 lmsec = convert_to_long(msec) 690 pdata = cty.cast(data, cty.c_void_p) 691 c_TimeoutCallback = FL_TIMEOUT_CALLBACK(py_TimeoutCallback) 692 keep_cfunc_refs(c_TimeoutCallback, py_TimeoutCallback) 693 keep_elem_refs(msec, lmsec, data, pdata) 694 retval = _fl_add_timeout(lmsec, c_TimeoutCallback, pdata) 695 return retval
696 697
698 -def fl_remove_timeout(idnum):
699 """ 700 fl_remove_timeout(idnum) 701 702 Removes a timeout callback function (created with fl_add_timeout). 703 704 @param idnum : ID timeout number 705 """ 706 707 _fl_remove_timeout = cfuncproto( 708 load_so_libforms(), "fl_remove_timeout", \ 709 None, [cty.c_int], \ 710 """void fl_remove_timeout(int id) 711 """) 712 iidnum = convert_to_int(idnum) 713 keep_elem_refs(idnum, iidnum) 714 _fl_remove_timeout(iidnum)
715 716 717 # Basic public routine prototypes 718 719 #def fl_library_version(ver, rev) *API change*
720 -def fl_library_version():
721 """ 722 fl_library_version() -> version_rev ID, ver, rev 723 724 Returns consolidated version informations. 725 726 Returns: 727 <version_rev> : computed as 1000 * version + revision 728 <ver> : version (e.g. 1 in 1.x.yy) 729 <rev> : revision (e.g. 0 in x.0.yy) 730 """ 731 732 _fl_library_version = cfuncproto( 733 load_so_libforms(), "fl_library_version", \ 734 cty.c_int, [cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)], \ 735 """int fl_library_version(int * ver, int * rev) 736 """) 737 ver, pver = make_int_and_pointer() 738 rev, prev = make_int_and_pointer() 739 keep_elem_refs(ver, rev, pver, prev) 740 retval = _fl_library_version(pver, prev) 741 return retval, ver, rev
742 743 744 # Generic routines that deal with FORMS 745
746 -def fl_bgn_form(formtype, w, h):
747 """ 748 fl_bgn_form(formtype, w, h) -> pForm 749 750 Starts the definition of a form call. 751 752 @param formtype : type of box that is used as a background 753 (e.g. FL_DOWN_BOX, FL_BORDER_BOX, FL_SHADOW_BOX, etc.) 754 @param w : width of the new form 755 @param h : height of the new form 756 """ 757 758 _fl_bgn_form = cfuncproto( 759 load_so_libforms(), "fl_bgn_form", \ 760 cty.POINTER(FL_FORM), [cty.c_int, FL_Coord, FL_Coord], \ 761 """FL_FORM * fl_bgn_form(int type, FL_Coord w, FL_Coord h) 762 """) 763 check_admitted_listvalues(formtype, BOXTYPE_list) 764 iformtype = convert_to_int(formtype) 765 iw = convert_to_FL_Coord(w) 766 ih = convert_to_FL_Coord(h) 767 keep_elem_refs(formtype, iformtype, w, iw, h, ih) 768 retval = _fl_bgn_form(iformtype, iw, ih) 769 return retval
770 771
772 -def fl_end_form():
773 """ 774 fl_end_form() 775 776 Ends the definition for a form call, after all required objects 777 have been added to a form call. 778 """ 779 780 _fl_end_form = cfuncproto( 781 load_so_libforms(), "fl_end_form", \ 782 None, [], \ 783 """void fl_end_form() 784 """) 785 _fl_end_form()
786 787
788 -def fl_do_forms():
789 """ 790 fl_do_forms() -> pObject 791 792 Starts the main loop of the program and returns only when the state 793 of an object changes that has no callback bound to it. 794 """ 795 796 _fl_do_forms = cfuncproto( 797 load_so_libforms(), "fl_do_forms", \ 798 cty.POINTER(FL_OBJECT), [], \ 799 """FL_OBJECT * fl_do_forms() 800 """) 801 retval = _fl_do_forms() 802 return retval
803 804
805 -def fl_check_forms():
806 """ 807 fl_check_forms() -> pObject 808 809 Returns None immediately unless the state of one of the object 810 (without a callback bound to it) changed. 811 """ 812 813 _fl_check_forms = cfuncproto( 814 load_so_libforms(), "fl_check_forms", \ 815 cty.POINTER(FL_OBJECT), [], \ 816 """FL_OBJECT * fl_check_forms() 817 """) 818 retval = _fl_check_forms() 819 return retval
820 821
822 -def fl_do_only_forms():
823 """ 824 fl_do_only_forms() -> pObject 825 826 Starts the main loop of the program and returns only when the state of 827 an object changes that has no callback bound to it. It does not 828 handle user events generated by application windows opened via 829 fl_winopen() or similar routines. 830 """ 831 832 _fl_do_only_forms = cfuncproto( 833 load_so_libforms(), "fl_do_only_forms", \ 834 cty.POINTER(FL_OBJECT), [], \ 835 """FL_OBJECT * fl_do_only_forms() 836 """) 837 retval = _fl_do_only_forms() 838 return retval
839 840
841 -def fl_check_only_forms():
842 """ 843 fl_check_only_forms() -> pObject 844 845 Returns None immediately unless the state of one of the object 846 (without a callback bound to it) changed. It does not handle user 847 events generated by application windows opened via fl_winopen() or 848 similar routines. 849 """ 850 851 _fl_check_only_forms = cfuncproto( 852 load_so_libforms(), "fl_check_only_forms", \ 853 cty.POINTER(FL_OBJECT), [], \ 854 """FL_OBJECT * fl_check_only_forms() 855 """) 856 retval = _fl_check_only_forms() 857 return retval
858 859
860 -def fl_freeze_form(pForm):
861 """ 862 fl_freeze_form(pForm) 863 864 It does not temporarily redraw a form while changes are being made, so 865 all changes made are instead buffered internally. 866 867 @param pForm : pointer to form not to be re-drawn temporarly 868 """ 869 870 _fl_freeze_form = cfuncproto( 871 load_so_libforms(), "fl_freeze_form", \ 872 None, [cty.POINTER(FL_FORM)], \ 873 """void fl_freeze_form(FL_FORM * form) 874 """) 875 keep_elem_refs(pForm) 876 _fl_freeze_form(pForm)
877 878
879 -def fl_set_focus_object(pForm, pObject):
880 """ 881 fl_set_focus_object(pForm, pObject) 882 883 Sets the input focus in form to object pObject. 884 885 @param pForm : pointer to form whose object has to be focused 886 @param pObject : pointer to object to be focused 887 """ 888 889 _fl_set_focus_object = cfuncproto( 890 load_so_libforms(), "fl_set_focus_object", \ 891 None, [cty.POINTER(FL_FORM), cty.POINTER(FL_OBJECT)], \ 892 """void fl_set_focus_object(FL_FORM * form, FL_OBJECT * obj) 893 """) 894 keep_elem_refs(pForm, pObject) 895 _fl_set_focus_object(pForm, pObject)
896 897 898 fl_set_object_focus = fl_set_focus_object 899 900
901 -def fl_get_focus_object(pForm):
902 """ 903 fl_get_focus_object(pForm) -> pObject 904 905 Obtains the object that has the focus on a form. 906 907 @param pForm : pointer to form that has a focused object 908 """ 909 910 _fl_get_focus_object = cfuncproto( 911 load_so_libforms(), "fl_get_focus_object", \ 912 cty.POINTER(FL_OBJECT), [cty.POINTER(FL_FORM)], \ 913 """FL_OBJECT * fl_get_focus_object(FL_FORM * form) 914 """) 915 keep_elem_refs(pForm) 916 retval = _fl_get_focus_object(pForm) 917 return retval
918 919
920 -def fl_reset_focus_object(pObject):
921 """ 922 fl_reset_focus_object(pObject) 923 924 Override the FL_UNFOCUS event. 925 926 @param pObject : pointer to object towards applying event 927 """ 928 929 _fl_reset_focus_object = cfuncproto( 930 load_so_libforms(), "fl_reset_focus_object", \ 931 None, [cty.POINTER(FL_OBJECT)], \ 932 """void fl_reset_focus_object(FL_OBJECT * ob) 933 """) 934 keep_elem_refs(pObject) 935 _fl_reset_focus_object(pObject)
936 937 938 #already defined in xfdata 939 #FL_FORM_ATCLOSE = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_FORM), cty.c_void_p) 940
941 -def fl_set_form_atclose(pForm, py_FormAtclose, data):
942 """ 943 fl_set_form_atclose(pForm, py_FormAtclose, data) -> FormAtclose func. 944 945 Calls a callback function before closing the form. 946 947 @param pForm : pointer to form that receives the message 948 @param py_FormAtclose : python callback function to be called, 949 fn(pForm, ptr_void) -> num 950 @param data : argument to be passed to function 951 """ 952 953 _fl_set_form_atclose = cfuncproto( 954 load_so_libforms(), "fl_set_form_atclose", \ 955 FL_FORM_ATCLOSE, [cty.POINTER(FL_FORM), FL_FORM_ATCLOSE, 956 cty.c_void_p], \ 957 """FL_FORM_ATCLOSE fl_set_form_atclose(FL_FORM * form, 958 FL_FORM_ATCLOSE fmclose, void * data) 959 """) 960 c_FormAtclose = FL_FORM_ATCLOSE(py_FormAtclose) 961 pdata = cty.cast(data, cty.c_void_p) 962 keep_cfunc_refs(c_FormAtclose, py_FormAtclose) 963 keep_elem_refs(pForm, data, pdata) 964 retval = _fl_set_form_atclose(pForm, c_FormAtclose, pdata) 965 return retval
966 967
968 -def fl_set_atclose(py_FormAtclose, data):
969 """ 970 fl_set_atclose(py_FormAtclose, data) -> FormAtclose func. 971 972 Calls a callback function before terminating the application. 973 974 @param py_FormAtclose : callback function to be called, fn(pForm, 975 ptr_void) -> num 976 @param data : argument to be passed to function 977 """ 978 979 _fl_set_atclose = cfuncproto( 980 load_so_libforms(), "fl_set_atclose", \ 981 FL_FORM_ATCLOSE, [FL_FORM_ATCLOSE, cty.c_void_p], \ 982 """FL_FORM_ATCLOSE fl_set_atclose(FL_FORM_ATCLOSE fmclose, 983 void * data) 984 """) 985 c_FormAtclose = FL_FORM_ATCLOSE(py_FormAtclose) 986 pdata = cty.cast(data, cty.c_void_p) 987 keep_cfunc_refs(c_FormAtclose, py_FormAtclose) 988 keep_elem_refs(data, pdata) 989 retval = _fl_set_atclose(c_FormAtclose, pdata) 990 return retval
991 992 993 #already defined in xfdata 994 #FL_FORM_ATACTIVATE = cty.CFUNCTYPE(None, cty.POINTER(FL_FORM), cty.c_void_p) 995
996 -def fl_set_form_atactivate(pForm, py_FormAtactivate, data):
997 """ 998 fl_set_form_atactivate(pForm, py_FormAtactivate, data) -> FormAtactivate func. 999 1000 Register a callback that is called when activation status of a forms 1001 is enabled, 1002 1003 @param pForm : activated form 1004 @param py_FormAtactivate : python callback function called, fn(pForm, 1005 ptr_void) 1006 @param data : argument to be passed to function 1007 """ 1008 1009 _fl_set_form_atactivate = cfuncproto( 1010 load_so_libforms(), "fl_set_form_atactivate", \ 1011 FL_FORM_ATACTIVATE, [cty.POINTER(FL_FORM), FL_FORM_ATACTIVATE, 1012 cty.c_void_p], \ 1013 """FL_FORM_ATACTIVATE fl_set_form_atactivate(FL_FORM * form, 1014 FL_FORM_ATACTIVATE cb, void * data) 1015 """) 1016 c_FormAtactivate = FL_FORM_ATACTIVATE(py_FormAtactivate) 1017 pdata = cty.cast(data, cty.c_void_p) 1018 keep_cfunc_refs(c_FormAtactivate, py_FormAtactivate) 1019 keep_elem_refs(pForm, data, pdata) 1020 retval = _fl_set_form_atactivate(pForm, c_FormAtactivate, pdata) 1021 return retval
1022 1023 1024 #already defined in xfdata 1025 #FL_FORM_ATDEACTIVATE = cty.CFUNCTYPE(None, cty.POINTER(FL_FORM), cty.c_void_p) 1026
1027 -def fl_set_form_atdeactivate(pForm, py_FormAtdeactivate, data):
1028 """ 1029 fl_set_form_atdeactivate(pForm, py_FormAtdeactivate, data) -> FormAtdeactivate func. 1030 1031 Register a callback that is called when activation status of a forms 1032 is disabled. 1033 1034 @param pForm : pointer to de-activated form 1035 @param py_FormAtdeactivate : python callback function called, 1036 fn(pForm, ptr_void) 1037 @param data : argument to be passed to function 1038 """ 1039 1040 _fl_set_form_atdeactivate = cfuncproto( 1041 load_so_libforms(), "fl_set_form_atdeactivate", \ 1042 FL_FORM_ATDEACTIVATE, [cty.POINTER(FL_FORM), 1043 FL_FORM_ATDEACTIVATE, cty.c_void_p], \ 1044 """FL_FORM_ATDEACTIVATE fl_set_form_atdeactivate(FL_FORM * form, 1045 FL_FORM_ATDEACTIVATE cb, void * data) 1046 """) 1047 c_FormAtdeactivate = FL_FORM_ATDEACTIVATE(py_FormAtdeactivate) 1048 pdata = cty.cast(data, cty.c_void_p) 1049 keep_cfunc_refs(c_FormAtdeactivate, py_FormAtdeactivate) 1050 keep_elem_refs(pForm, data, pdata) 1051 retval = _fl_set_form_atdeactivate(pForm, c_FormAtdeactivate, pdata) 1052 return retval
1053 1054
1055 -def fl_unfreeze_form(pForm):
1056 """ 1057 fl_unfreeze_form(pForm) 1058 1059 All changes made in the meantime in a form are drawn at once, 1060 reverting previous freeze. 1061 1062 @param pForm : pointer to form to be re-drawn after freezing 1063 """ 1064 1065 _fl_unfreeze_form = cfuncproto( 1066 load_so_libforms(), "fl_unfreeze_form", \ 1067 None, [cty.POINTER(FL_FORM)], \ 1068 """void fl_unfreeze_form(FL_FORM * form) 1069 """) 1070 keep_elem_refs(pForm) 1071 _fl_unfreeze_form(pForm)
1072 1073
1074 -def fl_deactivate_form(pForm):
1075 """ 1076 fl_deactivate_form(pForm) 1077 1078 Deactivates form temporarily, without hiding it, but not allowing the 1079 user to interact with elements contained in form (buttons, etc.). 1080 1081 @param pForm : pointer to form to be de-activated 1082 """ 1083 1084 _fl_deactivate_form = cfuncproto( 1085 load_so_libforms(), "fl_deactivate_form", \ 1086 None, [cty.POINTER(FL_FORM)], \ 1087 """void fl_deactivate_form(FL_FORM * form) 1088 """) 1089 keep_elem_refs(pForm) 1090 _fl_deactivate_form(pForm)
1091 1092
1093 -def fl_activate_form(pForm):
1094 """ 1095 fl_activate_form(pForm) 1096 1097 (Re)activates form, allowing the user to interact again with elements 1098 contained in form (buttons, etc.). 1099 1100 @param pForm : pointer to form to be re-activated 1101 """ 1102 1103 _fl_activate_form = cfuncproto( 1104 load_so_libforms(), "fl_activate_form", \ 1105 None, [cty.POINTER(FL_FORM)], \ 1106 """void fl_activate_form(FL_FORM * form) 1107 """) 1108 keep_elem_refs(pForm) 1109 _fl_activate_form(pForm)
1110 1111
1112 -def fl_deactivate_all_forms():
1113 """ 1114 fl_deactivate_all_forms() 1115 1116 De-activates all current forms, forbidding any user interactions. 1117 """ 1118 1119 _fl_deactivate_all_forms = cfuncproto( 1120 load_so_libforms(), "fl_deactivate_all_forms", \ 1121 None, [], \ 1122 """void fl_deactivate_all_forms() 1123 """) 1124 _fl_deactivate_all_forms()
1125 1126
1127 -def fl_activate_all_forms():
1128 """ 1129 fl_activate_all_forms() 1130 1131 (Re)activates all current forms, allowing user interaction. 1132 """ 1133 1134 _fl_activate_all_forms = cfuncproto( 1135 load_so_libforms(), "fl_activate_all_forms", \ 1136 None, [], \ 1137 """void fl_activate_all_forms() 1138 """) 1139 _fl_activate_all_forms()
1140 1141
1142 -def fl_freeze_all_forms():
1143 """ 1144 fl_freeze_all_forms() 1145 1146 It does not temporarily redraw all current forms while changes are 1147 being made, so all changes made are instead buffered internally. 1148 """ 1149 1150 _fl_freeze_all_forms = cfuncproto( 1151 load_so_libforms(), "fl_freeze_all_forms", \ 1152 None, [], \ 1153 """void fl_freeze_all_forms() 1154 """) 1155 _fl_freeze_all_forms()
1156 1157
1158 -def fl_unfreeze_all_forms():
1159 """ 1160 fl_unfreeze_all_forms() 1161 1162 All changes made in the meantime in all current forms are drawn at 1163 once, reverting previous freeze. 1164 """ 1165 1166 _fl_unfreeze_all_forms = cfuncproto( 1167 load_so_libforms(), "fl_unfreeze_all_forms", \ 1168 None, [], \ 1169 """void fl_unfreeze_all_forms() 1170 """) 1171 _fl_unfreeze_all_forms()
1172 1173
1174 -def fl_scale_form(pForm, xsc, ysc):
1175 """ 1176 fl_scale_form(pForm, xsc, ysc) 1177 1178 Scales a form and the objects on it in size and position, indicating 1179 a scaling factor in x- and y-direction with respect to the current 1180 size, and reshapes the window. 1181 1182 @param pForm : pointer to form to be scaled 1183 @param xsc : scaling factor in horizontal direction 1184 @param ysc : scaling factor in vertical direction 1185 """ 1186 1187 _fl_scale_form = cfuncproto( 1188 load_so_libforms(), "fl_scale_form", \ 1189 None, [cty.POINTER(FL_FORM), cty.c_double, cty.c_double], \ 1190 """void fl_scale_form(FL_FORM * form, double xsc, double ysc) 1191 """) 1192 fxsc = convert_to_double(xsc) 1193 fysc = convert_to_double(ysc) 1194 keep_elem_refs(pForm, xsc, fxsc, ysc, fysc) 1195 _fl_scale_form(pForm, fxsc, fysc)
1196 1197
1198 -def fl_set_form_position(pForm, x, y):
1199 """ 1200 fl_set_form_position(pForm, x, y) 1201 1202 Sets position of form, when placing a form on the screen with 1203 FL_PLACE_GEOMETRY as place argument. 1204 1205 @param pForm : pointer to form whose position is to be set 1206 @param x : horizontal position 1207 @param y : vertical position 1208 """ 1209 1210 _fl_set_form_position = cfuncproto( 1211 load_so_libforms(), "fl_set_form_position", \ 1212 None, [cty.POINTER(FL_FORM), FL_Coord, FL_Coord], \ 1213 """void fl_set_form_position(FL_FORM * form, FL_Coord x, 1214 FL_Coord y) 1215 """) 1216 ix = convert_to_FL_Coord(x) 1217 iy = convert_to_FL_Coord(y) 1218 keep_elem_refs(pForm, x, ix, y, iy) 1219 _fl_set_form_position(pForm, ix, iy)
1220 1221
1222 -def fl_set_form_title(pForm, name):
1223 """ 1224 fl_set_form_title(pForm, name) 1225 1226 Changes the form title (and the icon name) after it is shown. 1227 1228 @param pForm : pointer to form whose title has to be changed 1229 @param name : new name for the form 1230 """ 1231 1232 _fl_set_form_title = cfuncproto( 1233 load_so_libforms(), "fl_set_form_title", \ 1234 None, [cty.POINTER(FL_FORM), STRING], \ 1235 """void fl_set_form_title(FL_FORM * form, const char * name) 1236 """) 1237 sname = convert_to_string(name) 1238 keep_elem_refs(pForm, name, sname) 1239 _fl_set_form_title(pForm, sname)
1240 1241
1242 -def fl_set_app_mainform(pForm):
1243 """ fl_set_app_mainform(pForm) 1244 """ 1245 1246 _fl_set_app_mainform = cfuncproto( 1247 load_so_libforms(), "fl_set_app_mainform", 1248 None, [cty.POINTER(FL_FORM)], \ 1249 """void fl_set_app_mainform(FL_FORM * form) 1250 """) 1251 keep_elem_refs(pForm) 1252 _fl_set_app_mainform(pForm)
1253 1254
1255 -def fl_get_app_mainform():
1256 """ fl_get_app_mainform() -> pForm 1257 """ 1258 1259 _fl_get_app_mainform = cfuncproto( 1260 load_so_libforms(), "fl_get_app_mainform", 1261 cty.POINTER(FL_FORM), [], \ 1262 """FL_FORM * fl_get_app_mainform() 1263 """) 1264 retval = _fl_get_app_mainform() 1265 return retval
1266 1267
1268 -def fl_set_app_nomainform(flag):
1269 """ fl_set_app_nomainform(flag) 1270 """ 1271 1272 _fl_set_app_nomainform = cfuncproto( 1273 load_so_libforms(), "fl_set_app_nomainform", 1274 None, [cty.c_int], \ 1275 """void fl_set_app_nomainform(int flag) 1276 """) 1277 iflag = convert_to_int(flag) 1278 keep_elem_refs(flag, iflag) 1279 _fl_set_app_nomainform(iflag)
1280 1281 1282 #already defined in xfdata 1283 #FL_FORMCALLBACKPTR = cty.CFUNCTYPE(None, cty.POINTER(FL_OBJECT), cty.c_void_p) 1284
1285 -def fl_set_form_callback(pForm, py_FormCallbackPtr, data):
1286 """ fl_set_form_callback(pForm, py_FormCallbackPtr, data) 1287 1288 Sets the callback routine for the form. 1289 1290 @param pForm : pointer to form 1291 @param py_FormCallbackPtr : python callback to be set, 1292 fn(pObject, ptr_void) 1293 @param data : argument to be passed to function 1294 """ 1295 1296 _fl_set_form_callback = cfuncproto( 1297 load_so_libforms(), "fl_set_form_callback", \ 1298 None, [cty.POINTER(FL_FORM), FL_FORMCALLBACKPTR, cty.c_void_p], \ 1299 """void fl_set_form_callback(FL_FORM * form, 1300 FL_FORMCALLBACKPTR callback, void * d) 1301 """) 1302 c_FormCallbackPtr = FL_FORMCALLBACKPTR(py_FormCallbackPtr) 1303 pdata = cty.cast(data, cty.c_void_p) 1304 keep_cfunc_refs(c_FormCallbackPtr, py_FormCallbackPtr) 1305 keep_elem_refs(pForm, data, pdata) 1306 _fl_set_form_callback(pForm, c_FormCallbackPtr, pdata)
1307 1308 1309 fl_set_form_call_back = fl_set_form_callback 1310 1311
1312 -def fl_set_form_size(pForm, w, h):
1313 """ 1314 fl_set_form_size(pForm, w, h) 1315 1316 Sets the size of form. 1317 1318 @param pForm : pointer to form 1319 @param w : width of form 1320 @param h : height of form 1321 """ 1322 1323 _fl_set_form_size = cfuncproto( 1324 load_so_libforms(), "fl_set_form_size", \ 1325 None, [cty.POINTER(FL_FORM), FL_Coord, FL_Coord], \ 1326 """void fl_set_form_size(FL_FORM * form, FL_Coord w, FL_Coord h) 1327 """) 1328 iw = convert_to_FL_Coord(w) 1329 ih = convert_to_FL_Coord(h) 1330 keep_elem_refs(pForm, w, iw, h, ih) 1331 _fl_set_form_size(pForm, iw, ih)
1332 1333
1334 -def fl_set_form_hotspot(pForm, x, y):
1335 """ 1336 fl_set_form_hotspot(pForm, x, y) 1337 1338 Sets the position of the hotspot of a form. 1339 1340 @param pForm : pointer to form 1341 @param x : horizontal position 1342 @param y : vertical position 1343 """ 1344 1345 _fl_set_form_hotspot = cfuncproto( 1346 load_so_libforms(), "fl_set_form_hotspot", \ 1347 None, [cty.POINTER(FL_FORM), FL_Coord, FL_Coord], \ 1348 """void fl_set_form_hotspot(FL_FORM * form, FL_Coord x, 1349 FL_Coord y) 1350 """) 1351 ix = convert_to_FL_Coord(x) 1352 iy = convert_to_FL_Coord(y) 1353 keep_elem_refs(pForm, x, ix, y, iy) 1354 _fl_set_form_hotspot(pForm, ix, iy)
1355 1356
1357 -def fl_set_form_hotobject(pForm, pObject):
1358 """ 1359 fl_set_form_hotobject(pForm, pObject) 1360 1361 @param pForm : pointer to form 1362 @param pObject : pointer to object 1363 """ 1364 1365 _fl_set_form_hotobject = cfuncproto( 1366 load_so_libforms(), "fl_set_form_hotobject", \ 1367 None, [cty.POINTER(FL_FORM), cty.POINTER(FL_OBJECT)], \ 1368 """void fl_set_form_hotobject(FL_FORM * form, FL_OBJECT * ob) 1369 """) 1370 keep_elem_refs(pForm, pObject) 1371 _fl_set_form_hotobject(pForm, pObject)
1372 1373
1374 -def fl_set_form_minsize(pForm, w, h):
1375 """ 1376 fl_set_form_minsize(pForm, w, h) 1377 1378 @param pForm : pointer to form 1379 @param w : width of form 1380 @param h : height of form 1381 """ 1382 1383 _fl_set_form_minsize = cfuncproto( 1384 load_so_libforms(), "fl_set_form_minsize", \ 1385 None, [cty.POINTER(FL_FORM), FL_Coord, FL_Coord], \ 1386 """void fl_set_form_minsize(FL_FORM * form, FL_Coord w, FL_Coord h) 1387 """) 1388 iw = convert_to_FL_Coord(w) 1389 ih = convert_to_FL_Coord(h) 1390 keep_elem_refs(pForm, w, iw, h, ih) 1391 _fl_set_form_minsize(pForm, iw, ih)
1392 1393
1394 -def fl_set_form_maxsize(pForm, w, h):
1395 """ 1396 fl_set_form_maxsize(pForm, w, h) 1397 1398 @param pForm : pointer to form 1399 @param w : width of form 1400 @param h : height of form 1401 """ 1402 1403 _fl_set_form_maxsize = cfuncproto( 1404 load_so_libforms(), "fl_set_form_maxsize", \ 1405 None, [cty.POINTER(FL_FORM), FL_Coord, FL_Coord], \ 1406 """void fl_set_form_maxsize(FL_FORM * form, FL_Coord w, FL_Coord h) 1407 """) 1408 iw = convert_to_FL_Coord(w) 1409 ih = convert_to_FL_Coord(h) 1410 keep_elem_refs(pForm, w, iw, h, ih) 1411 _fl_set_form_maxsize(pForm, iw, ih)
1412 1413
1414 -def fl_set_form_event_cmask(pForm, cmask):
1415 """ 1416 fl_set_form_event_cmask(pForm, cmask) 1417 1418 @param pForm : pointer to form 1419 @param cmask : compress mask for form 1420 """ 1421 1422 _fl_set_form_event_cmask = cfuncproto( 1423 load_so_libforms(), "fl_set_form_event_cmask", \ 1424 None, [cty.POINTER(FL_FORM), cty.c_ulong], \ 1425 """void fl_set_form_event_cmask(FL_FORM * form, 1426 long unsigned int cmask) 1427 """) 1428 ulcmask = convert_to_ulong(cmask) 1429 keep_elem_refs(pForm, cmask, ulcmask) 1430 _fl_set_form_event_cmask(pForm, ulcmask)
1431 1432
1433 -def fl_get_form_event_cmask(pForm):
1434 """ 1435 fl_get_form_event_cmask(pForm) -> cmask ID 1436 1437 @param pForm : pointer to form 1438 @returns : compress mask for form 1439 """ 1440 1441 _fl_get_form_event_cmask = cfuncproto( 1442 load_so_libforms(), "fl_get_form_event_cmask", \ 1443 cty.c_ulong, [cty.POINTER(FL_FORM)], \ 1444 """long unsigned int fl_get_form_event_cmask(FL_FORM * form) 1445 """) 1446 keep_elem_refs(pForm) 1447 retval = _fl_get_form_event_cmask(pForm) 1448 return retval
1449 1450 1451 # alert until upstream bugfix
1452 -def fl_set_form_geometry(pForm, x, y, w, h):
1453 """ 1454 fl_set_form_geometry(pForm, x, y, w, h) 1455 1456 @param pForm : pointer to form 1457 @param x : horizontal position 1458 @param y : vertical position 1459 @param w : width of form 1460 @param h : height of form 1461 """ 1462 1463 _fl_set_form_geometry = cfuncproto( 1464 load_so_libforms(), "fl_set_form_geometry", \ 1465 None, [cty.POINTER(FL_FORM), FL_Coord, FL_Coord, 1466 FL_Coord, FL_Coord], \ 1467 """void fl_set_form_geometry(FL_FORM * form, FL_Coord x, 1468 FL_Coord y, FL_Coord w, FL_Coord h) 1469 """) 1470 ix = convert_to_FL_Coord(x) 1471 iy = convert_to_FL_Coord(y) 1472 iw = convert_to_FL_Coord(w) 1473 ih = convert_to_FL_Coord(h) 1474 keep_elem_refs(pForm, x, ix, y, iy, w, iw, h, ih) 1475 _fl_set_form_geometry(pForm, ix, iy, iw, ih)
1476 1477 1478 fl_set_initial_placement = fl_set_form_geometry 1479 1480
1481 -def fl_show_form(pForm, place, border, title):
1482 """ 1483 fl_show_form(pForm, place, border, title) -> window id 1484 1485 Shows the form. 1486 1487 @param pForm : pointer to form 1488 @param place : where form has to be placed 1489 @param border : type of window manager decoration 1490 @param title : title of form 1491 """ 1492 1493 _fl_show_form = cfuncproto( 1494 load_so_libforms(), "fl_show_form", 1495 Window, [cty.POINTER(FL_FORM), cty.c_int, cty.c_int, STRING], \ 1496 """Window fl_show_form(FL_FORM * form, int place, int border, 1497 const char * name) 1498 """) 1499 check_admitted_listvalues(place, PLACE_list) 1500 check_admitted_listvalues(border, DECORATION_list) 1501 iplace = convert_to_int(place) 1502 iborder = convert_to_int(border) 1503 stitle = convert_to_string(title) 1504 keep_elem_refs(pForm, place, iplace, border, iborder, title, stitle) 1505 retval = _fl_show_form(pForm, iplace, iborder, stitle) 1506 return retval
1507 1508
1509 -def fl_hide_form(pForm):
1510 """ 1511 fl_hide_form(pForm) 1512 1513 Hides the form. 1514 1515 @param pForm : pointer to form 1516 """ 1517 1518 _fl_hide_form = cfuncproto( 1519 load_so_libforms(), "fl_hide_form", 1520 None, [cty.POINTER(FL_FORM)], \ 1521 """void fl_hide_form(FL_FORM * form) 1522 """) 1523 keep_elem_refs(pForm) 1524 _fl_hide_form(pForm)
1525 1526
1527 -def fl_free_form(pForm):
1528 """ 1529 fl_free_form(pForm) 1530 1531 Frees the memory used by a form together with all its objects. 1532 1533 @param pForm : pointer to form to be freed 1534 """ 1535 1536 _fl_free_form = cfuncproto( 1537 load_so_libforms(), "fl_free_form", 1538 None, [cty.POINTER(FL_FORM)], \ 1539 """void fl_free_form(FL_FORM * form) 1540 """) 1541 keep_elem_refs(pForm) 1542 _fl_free_form(pForm)
1543 1544
1545 -def fl_redraw_form(pForm):
1546 """ 1547 fl_redraw_form(pForm) 1548 1549 Draws a form. 1550 1551 @param pForm : pointer to form 1552 """ 1553 1554 _fl_redraw_form = cfuncproto( 1555 load_so_libforms(), "fl_redraw_form", 1556 None, [cty.POINTER(FL_FORM)], \ 1557 """void fl_redraw_form(FL_FORM * form) 1558 """) 1559 keep_elem_refs(pForm) 1560 _fl_redraw_form(pForm)
1561 1562
1563 -def fl_set_form_dblbuffer(pForm, y):
1564 """ 1565 fl_set_form_dblbuffer(pForm, y) 1566 1567 @param pForm : pointer to form 1568 @param y : flag (0|1) for disabling/enabling doublebuffer 1569 """ 1570 1571 _fl_set_form_dblbuffer = cfuncproto( 1572 load_so_libforms(), "fl_set_form_dblbuffer", \ 1573 None, [cty.POINTER(FL_FORM), cty.c_int], \ 1574 """void fl_set_form_dblbuffer(FL_FORM * form, int y) 1575 """) 1576 iy = convert_to_int(y) 1577 keep_elem_refs(pForm, y, iy) 1578 _fl_set_form_dblbuffer(pForm, iy)
1579 1580
1581 -def fl_prepare_form_window(pForm, place, border, name):
1582 """ 1583 fl_prepare_form_window(pForm, place, border, name) -> window ID 1584 1585 Displays a particular form, returns its window handle. 1586 1587 @param pForm : pointer to form 1588 @param place : where has to be placed 1589 @param border : window manager decoration 1590 @param name : title of form 1591 """ 1592 1593 _fl_prepare_form_window = cfuncproto( 1594 load_so_libforms(), "fl_prepare_form_window", \ 1595 Window, [cty.POINTER(FL_FORM), cty.c_int, cty.c_int, STRING], \ 1596 """Window fl_prepare_form_window(FL_FORM * form, int place, 1597 int border, const char * name) 1598 """) 1599 iplace = convert_to_int(place) 1600 iborder = convert_to_int(border) 1601 sname = convert_to_string(name) 1602 keep_elem_refs(pForm, place, iplace, border, iborder, name, sname) 1603 retval = _fl_prepare_form_window(pForm, iplace, iborder, sname) 1604 return retval
1605 1606
1607 -def fl_show_form_window(pForm):
1608 """ 1609 fl_show_form_window(pForm) -> window ID 1610 1611 @param pForm : pointer to form 1612 """ 1613 1614 _fl_show_form_window = cfuncproto( 1615 load_so_libforms(), "fl_show_form_window", \ 1616 Window, [cty.POINTER(FL_FORM)], \ 1617 """Window fl_show_form_window(FL_FORM * form) 1618 """) 1619 keep_elem_refs(pForm) 1620 retval = _fl_show_form_window(pForm) 1621 return retval
1622 1623
1624 -def fl_adjust_form_size(pForm):
1625 """ 1626 fl_adjust_form_size(pForm) -> max_factor id 1627 1628 Similar to fl_fit_object_label, but will do it for all objects and 1629 has a smaller threshold. Mainly intended for compensation for font 1630 size variations. 1631 1632 @param pForm : pointer to form 1633 """ 1634 1635 _fl_adjust_form_size = cfuncproto( 1636 load_so_libforms(), "fl_adjust_form_size", \ 1637 cty.c_double, [cty.POINTER(FL_FORM)], \ 1638 """double fl_adjust_form_size(FL_FORM * form) 1639 """) 1640 keep_elem_refs(pForm) 1641 retval = _fl_adjust_form_size(pForm) 1642 return retval
1643 1644
1645 -def fl_form_is_visible(pForm):
1646 """ 1647 fl_form_is_visible(pForm) -> state id 1648 1649 Returns if form is visible. 1650 1651 @param pForm : pointer to form 1652 """ 1653 1654 _fl_form_is_visible = cfuncproto( 1655 load_so_libforms(), "fl_form_is_visible", \ 1656 cty.c_int, [cty.POINTER(FL_FORM)], \ 1657 """int fl_form_is_visible(FL_FORM * form) 1658 """) 1659 keep_elem_refs(pForm) 1660 retval = _fl_form_is_visible(pForm) 1661 return retval
1662 1663
1664 -def fl_form_is_iconified(pForm):
1665 """ 1666 fl_form_is_iconified(pForm) -> state id 1667 1668 Returns if a forms window is in iconified state. 1669 1670 @param pForm : pointer to form 1671 """ 1672 1673 _fl_form_is_iconified = cfuncproto( 1674 load_so_libforms(), "fl_form_is_iconified", \ 1675 cty.c_int, [cty.POINTER(FL_FORM)], \ 1676 """int fl_form_is_iconified(FL_FORM * form) 1677 """) 1678 keep_elem_refs(pForm) 1679 retval = _fl_form_is_iconified(pForm) 1680 return retval
1681 1682 1683 #already defined in xfdata 1684 #FL_RAW_CALLBACK = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_FORM), cty.c_void_p) 1685
1686 -def fl_register_raw_callback(pForm, mask, py_RawCallback):
1687 """ 1688 fl_register_raw_callback(pForm, mask, py_RawCallback) -> old raw_callback func. 1689 1690 Register pre-emptive event handlers. 1691 1692 @param pForm : pointer to form 1693 @param mask : key/button/window event mask (press, release, motion, 1694 enter, leave etc..) 1695 @param py_RawCallback : python callback function, 1696 fn(pForm, ptr_void) -> num 1697 """ 1698 1699 _fl_register_raw_callback = cfuncproto( 1700 load_so_libforms(), "fl_register_raw_callback", \ 1701 FL_RAW_CALLBACK, [cty.POINTER(FL_FORM), cty.c_ulong, 1702 FL_RAW_CALLBACK], \ 1703 """FL_RAW_CALLBACK fl_register_raw_callback(FL_FORM * form, 1704 long unsigned int mask, FL_RAW_CALLBACK rcb) 1705 """) 1706 ulmask = convert_to_ulong(mask) 1707 c_RawCallback = FL_RAW_CALLBACK(py_RawCallback) 1708 keep_cfunc_refs(c_RawCallback, py_RawCallback) 1709 keep_elem_refs(pForm, mask, ulmask) 1710 retval = _fl_register_raw_callback(pForm, ulmask, c_RawCallback) 1711 return retval
1712 1713 1714 fl_register_call_back = fl_register_raw_callback 1715 1716
1717 -def fl_bgn_group():
1718 """ 1719 fl_bgn_group() -> pObject 1720 1721 Starts a group definition. 1722 """ 1723 1724 _fl_bgn_group = cfuncproto( 1725 load_so_libforms(), "fl_bgn_group", \ 1726 cty.POINTER(FL_OBJECT), [], \ 1727 """FL_OBJECT * fl_bgn_group() 1728 """) 1729 retval = _fl_bgn_group() 1730 return retval
1731 1732
1733 -def fl_end_group():
1734 """ 1735 fl_end_group() 1736 1737 Ends a group definition. 1738 """ 1739 1740 _fl_end_group = cfuncproto( 1741 load_so_libforms(), "fl_end_group", \ 1742 None, [], \ 1743 """void fl_end_group() 1744 """) 1745 _fl_end_group()
1746 1747
1748 -def fl_addto_group(pGroup):
1749 """ 1750 fl_addto_group(pGroup) -> pForm 1751 1752 Reopens a group to allow addition of further objects. 1753 1754 @param pGroup : pointer to group object to reopen 1755 """ 1756 1757 _fl_addto_group = cfuncproto( 1758 load_so_libforms(), "fl_addto_group", \ 1759 cty.POINTER(FL_OBJECT), [cty.POINTER(FL_OBJECT)], \ 1760 """FL_OBJECT * fl_addto_group(FL_OBJECT * group) 1761 """) 1762 keep_elem_refs(pGroup) 1763 retval = _fl_addto_group(pGroup) 1764 return retval
1765 1766 1767 # Routines that deal with FL_OBJECTS 1768 1769
1770 -def fl_get_object_objclass(pObject):
1771 """ 1772 fl_get_object_objclass(pObject) -> objclass id 1773 1774 Return the objclass of an object. 1775 1776 @param pObject : pointer to object 1777 """ 1778 1779 _fl_get_object_objclass = cfuncproto( 1780 load_so_libforms(), "fl_get_object_obclass", \ 1781 cty.c_int, [cty.POINTER(FL_OBJECT)], \ 1782 """int fl_get_object_objclass(FL_OBJECT * obj) 1783 """) 1784 keep_elem_refs(pObject) 1785 retval = _fl_get_object_objclass(pObject) 1786 return retval
1787 1788
1789 -def fl_get_object_type(pObject):
1790 """ 1791 fl_get_object_type(pObject) -> type id 1792 1793 Return the type of an object. 1794 1795 @param pObject : pointer to object 1796 """ 1797 1798 _fl_get_object_type = cfuncproto( 1799 load_so_libforms(), "fl_get_object_type", \ 1800 cty.c_int, [cty.POINTER(FL_OBJECT)], \ 1801 """int fl_get_object_type(FL_OBJECT * obj) 1802 """) 1803 keep_elem_refs(pObject) 1804 retval = _fl_get_object_type(pObject) 1805 return retval
1806 1807
1808 -def fl_set_object_boxtype(pObject, boxtype):
1809 """ 1810 fl_set_object_boxtype(pObject, boxtype) 1811 1812 Sets the type of box of an object. 1813 1814 @param pObject : pointer to object 1815 @param boxtype : type of the box 1816 """ 1817 1818 _fl_set_object_boxtype = cfuncproto( 1819 load_so_libforms(), "fl_set_object_boxtype", \ 1820 None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 1821 """void fl_set_object_boxtype(FL_OBJECT * ob, int boxtype) 1822 """) 1823 check_admitted_listvalues(boxtype, BOXTYPE_list) 1824 iboxtype = convert_to_int(boxtype) 1825 keep_elem_refs(pObject, boxtype, iboxtype) 1826 _fl_set_object_boxtype(pObject, iboxtype)
1827 1828
1829 -def fl_get_object_boxtype(pObject):
1830 """ 1831 fl_get_object_boxtype(pObject) -> boxtype id 1832 1833 Return the boxtype of an object. 1834 1835 @param pObject : pointer to object 1836 """ 1837 1838 _fl_get_object_boxtype = cfuncproto( 1839 load_so_libforms(), "fl_get_object_boxtype", \ 1840 cty.c_int, [cty.POINTER(FL_OBJECT)], \ 1841 """int fl_get_object_boxtype(FL_OBJECT * obj) 1842 """) 1843 keep_elem_refs(pObject) 1844 retval = _fl_get_object_boxtype(pObject) 1845 return retval
1846 1847
1848 -def fl_set_object_bw(pObject, bw):
1849 """ 1850 fl_set_object_bw(pObject, bw) 1851 1852 Sets the borderwidth of an object. 1853 1854 @param pObject : pointer to object 1855 @param bw : borderwidth of object 1856 """ 1857 1858 _fl_set_object_bw = cfuncproto( 1859 load_so_libforms(), "fl_set_object_bw", \ 1860 None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 1861 """void fl_set_object_bw(FL_OBJECT * ob, int bw) 1862 """) 1863 ibw = convert_to_int(bw) 1864 keep_elem_refs(pObject, bw, ibw) 1865 _fl_set_object_bw(pObject, ibw)
1866 1867 1868 #def fl_get_object_bw(pObject, bw) *API change*
1869 -def fl_get_object_bw(pObject):
1870 """ 1871 fl_get_object_bw(pObject) -> bw 1872 1873 Returns the borderwidth of an object. 1874 1875 @param pObject : pointer to object 1876 """ 1877 1878 _fl_get_object_bw = cfuncproto( 1879 load_so_libforms(), "fl_get_object_bw", \ 1880 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int)], \ 1881 """void fl_get_object_bw(FL_OBJECT * ob, int * bw) 1882 """) 1883 bw, pbw = make_int_and_pointer() 1884 keep_elem_refs(pObject, bw, pbw) 1885 _fl_get_object_bw(pObject, pbw) 1886 return bw
1887 1888
1889 -def fl_set_object_resize(pObject, what):
1890 """ 1891 fl_set_object_resize(pObject, what) 1892 1893 Sets the resize property of an object. 1894 1895 @param pObject : pointer to object 1896 @param what : resize property 1897 """ 1898 1899 _fl_set_object_resize = cfuncproto( 1900 load_so_libforms(), "fl_set_object_resize", \ 1901 None, [cty.POINTER(FL_OBJECT), cty.c_uint], \ 1902 """void fl_set_object_resize(FL_OBJECT * ob, unsigned int what) 1903 """) 1904 uiwhat = convert_to_uint(what) 1905 keep_elem_refs(pObject, what, uiwhat) 1906 _fl_set_object_resize(pObject, uiwhat)
1907 1908 1909 #def fl_get_object_resize(pObject, what) *API change*
1910 -def fl_get_object_resize(pObject):
1911 """ 1912 fl_get_object_resize(pObject) -> what 1913 1914 Returns the resize property of an object. 1915 1916 @param pObject : pointer to object 1917 """ 1918 1919 _fl_get_object_resize = cfuncproto( 1920 load_so_libforms(), "fl_get_object_resize", \ 1921 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_uint)], \ 1922 """void fl_get_object_resize(FL_OBJECT * ob, unsigned int * what) 1923 """) 1924 what, pwhat = make_uint_and_pointer() 1925 keep_elem_refs(pObject, what, pwhat) 1926 _fl_get_object_resize(pObject, pwhat) 1927 return what
1928 1929
1930 -def fl_set_object_gravity(pObject, nw, se):
1931 """ 1932 fl_set_object_gravity(pObject, nw, se) 1933 1934 Sets the gravity properties of an object. 1935 1936 @param pObject : pointer to object 1937 @param nw : gravity property for NorthWest 1938 @param se : gravity property for SouthEast 1939 """ 1940 1941 _fl_set_object_gravity = cfuncproto( 1942 load_so_libforms(), "fl_set_object_gravity", \ 1943 None, [cty.POINTER(FL_OBJECT), cty.c_uint, cty.c_uint], \ 1944 """void fl_set_object_gravity(FL_OBJECT * ob, unsigned int nw, 1945 unsigned int se) 1946 """) 1947 uinw = convert_to_uint(nw) 1948 uise = convert_to_uint(se) 1949 keep_elem_refs(pObject, nw, uinw, se, uise) 1950 _fl_set_object_gravity(pObject, uinw, uise)
1951 1952 1953 #def fl_get_object_gravity(pObject, nw, se) *API change*
1954 -def fl_get_object_gravity(pObject):
1955 """ 1956 fl_get_object_gravity(pObject) -> nw, se 1957 1958 Returns the gravity properties of an object. 1959 1960 @param pObject : pointer to object 1961 """ 1962 1963 _fl_get_object_gravity = cfuncproto( 1964 load_so_libforms(), "fl_get_object_gravity", \ 1965 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_uint), 1966 cty.POINTER(cty.c_uint)], \ 1967 """void fl_get_object_gravity(FL_OBJECT * ob, unsigned int * nw, 1968 unsigned int * se) 1969 """) 1970 nw, pnw = make_uint_and_pointer() 1971 se, pse = make_uint_and_pointer() 1972 keep_elem_refs(pObject, nw, se, pnw, pse) 1973 _fl_get_object_gravity(pObject, pnw, pse) 1974 return nw, se
1975 1976
1977 -def fl_set_object_lsize(pObject, lsize):
1978 """ 1979 fl_set_object_lsize(pObject, lsize) 1980 1981 Sets the label size of an object. 1982 1983 @param pObject : pointer to object 1984 @param lsize : label size 1985 """ 1986 1987 _fl_set_object_lsize = cfuncproto( 1988 load_so_libforms(), "fl_set_object_lsize", \ 1989 None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 1990 """void fl_set_object_lsize(FL_OBJECT * ob, int lsize) 1991 """) 1992 ilsize = convert_to_int(lsize) 1993 keep_elem_refs(pObject, lsize, ilsize) 1994 _fl_set_object_lsize(pObject, ilsize)
1995 1996
1997 -def fl_get_object_lsize(pObject):
1998 """ 1999 fl_get_object_lsize(pObject) -> lsize num. 2000 2001 Returns the label size of an object. 2002 2003 @param pObject : pointer to object 2004 """ 2005 2006 _fl_get_object_lsize = cfuncproto( 2007 load_so_libforms(), "fl_get_object_lsize", \ 2008 cty.c_int, [cty.POINTER(FL_OBJECT)], \ 2009 """int fl_get_object_lsize(FL_OBJECT * obj) 2010 """) 2011 keep_elem_refs(pObject) 2012 retval = _fl_get_object_lsize(pObject) 2013 return retval
2014 2015
2016 -def fl_set_object_lstyle(pObject, lstyle):
2017 """ 2018 fl_set_object_lstyle(pObject, lstyle) 2019 2020 Sets the label style of an object. 2021 2022 @param pObject : pointer to object 2023 @param lstyle : label style 2024 """ 2025 2026 _fl_set_object_lstyle = cfuncproto( 2027 load_so_libforms(), "fl_set_object_lstyle", \ 2028 None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 2029 """void fl_set_object_lstyle(FL_OBJECT * ob, int lstyle) 2030 """) 2031 check_admitted_listvalues(lstyle, TEXTSTYLE_list) 2032 ilstyle = convert_to_int(lstyle) 2033 keep_elem_refs(pObject, lstyle, ilstyle) 2034 _fl_set_object_lstyle(pObject, ilstyle)
2035 2036
2037 -def fl_get_object_lstyle(pObject):
2038 """ 2039 fl_get_object_lstyle(pObject) -> lstyle num. 2040 2041 Returns the label style of an object. 2042 2043 @param pObject : pointer to object 2044 """ 2045 2046 _fl_get_object_lstyle = cfuncproto( 2047 load_so_libforms(), "fl_get_object_lstyle", \ 2048 cty.c_int, [cty.POINTER(FL_OBJECT)], \ 2049 """int fl_get_object_lstyle(FL_OBJECT * obj) 2050 """) 2051 keep_elem_refs(pObject) 2052 retval = _fl_get_object_lstyle(pObject) 2053 return retval
2054 2055
2056 -def fl_set_object_lcol(pObject, lcolr):
2057 """ 2058 fl_set_object_lcol(pObject, lcolr) 2059 2060 Sets the label color of an object. 2061 2062 @param pObject : pointer to object 2063 @param lcolr : label color 2064 """ 2065 2066 _fl_set_object_lcol = cfuncproto( 2067 load_so_libforms(), "fl_set_object_lcol", \ 2068 None, [cty.POINTER(FL_OBJECT), FL_COLOR], \ 2069 """void fl_set_object_lcol(FL_OBJECT * ob, FL_COLOR lcol) 2070 """) 2071 check_admitted_listvalues(lcolr, COLOR_list) 2072 ullcolr = convert_to_FL_COLOR(lcolr) 2073 keep_elem_refs(pObject, lcolr, ullcolr) 2074 _fl_set_object_lcol(pObject, ullcolr)
2075 2076
2077 -def fl_get_object_lcol(pObject):
2078 """ 2079 fl_get_object_lcol(pObject) -> color 2080 2081 Returns the label color of an object. 2082 2083 @param pObject : pointer to object 2084 """ 2085 2086 _fl_get_object_lcol = cfuncproto( 2087 load_so_libforms(), "fl_get_object_lcol", \ 2088 FL_COLOR, [cty.POINTER(FL_OBJECT)], \ 2089 """FL_COLOR fl_set_object_lcol(FL_OBJECT * obj) 2090 """) 2091 keep_elem_refs(pObject) 2092 retval = _fl_get_object_lcol(pObject) 2093 return retval
2094 2095
2096 -def fl_set_object_return(pObject, when):
2097 """ 2098 fl_set_object_return(pObject, when) -> ID num 2099 2100 Function for setting the conditions under which an object gets 2101 returned (or its callback invoked). If the object has to do 2102 additional work on setting te condition (e.g. it has child 2103 objects that also need to be set) it has to set up it's own 2104 function that then will called in the end. This function should 2105 only be called once an object has been created completely! 2106 2107 @param pObject : pointer to object 2108 @param when : return type 2109 """ 2110 2111 _fl_set_object_return = cfuncproto( 2112 load_so_libforms(), "fl_set_object_return", \ 2113 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], \ 2114 """int fl_set_object_return(FL_OBJECT * ob, int when) DEPRECATED 2115 """) 2116 check_admitted_listvalues(when, RETURN_list) 2117 iwhen = convert_to_int(when) 2118 keep_elem_refs(pObject, when, iwhen) 2119 retval = _fl_set_object_return(pObject, iwhen) 2120 return retval
2121 2122
2123 -def fl_notify_object(pObject, cause):
2124 """ 2125 fl_notify_object(pObject, cause) 2126 2127 @param pObject : pointer to object 2128 @param cause : ? 2129 """ 2130 2131 _fl_notify_object = cfuncproto( 2132 load_so_libforms(), "fl_notify_object", \ 2133 None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 2134 """void fl_notify_object(FL_OBJECT * obj, int cause) 2135 """) 2136 icause = convert_to_int(cause) 2137 keep_elem_refs(pObject, cause, icause) 2138 _fl_notify_object(pObject, icause)
2139 2140
2141 -def fl_set_object_lalign(pObject, align):
2142 """ 2143 fl_set_object_lalign(pObject, align) 2144 2145 Sets alignment of an object. 2146 2147 @param pObject : pointer to object 2148 @param align : alignment of object 2149 """ 2150 2151 _fl_set_object_lalign = cfuncproto( 2152 load_so_libforms(), "fl_set_object_lalign", \ 2153 None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 2154 """void fl_set_object_lalign(FL_OBJECT * ob, int align) 2155 """) 2156 check_admitted_listvalues(align, ALIGN_list) 2157 ialign = convert_to_int(align) 2158 keep_elem_refs(pObject, align, ialign) 2159 _fl_set_object_lalign(pObject, ialign)
2160 2161
2162 -def fl_get_object_lalign(pObject):
2163 """ 2164 fl_get_object_lalign(pObject) -> align num. 2165 2166 Returns alignment of an object. 2167 2168 @param pObject : pointer to object 2169 """ 2170 2171 _fl_get_object_lalign = cfuncproto( 2172 load_so_libforms(), "fl_get_object_lalign", \ 2173 cty.c_int, [cty.POINTER(FL_OBJECT)], \ 2174 """int fl_set_object_lalign(FL_OBJECT * ob) 2175 """) 2176 keep_elem_refs(pObject) 2177 retval = _fl_get_object_lalign(pObject) 2178 return retval
2179 2180
2181 -def fl_set_object_shortcut(pObject, sstr, showit):
2182 """ 2183 fl_set_object_shortcut(pObject, sstr, showit) 2184 2185 @param pObject : pointer to object 2186 @param sstr : shortcut string 2187 @param showit : flag (0|1) 2188 """ 2189 2190 _fl_set_object_shortcut = cfuncproto( 2191 load_so_libforms(), "fl_set_object_shortcut", \ 2192 None, [cty.POINTER(FL_OBJECT), STRING, cty.c_int], \ 2193 """void fl_set_object_shortcut(FL_OBJECT * obj, 2194 const char * sstr, int showit) 2195 """) 2196 ssstr = convert_to_string(sstr) 2197 ishowit = convert_to_int(showit) 2198 keep_elem_refs(pObject, sstr, ssstr, showit, ishowit) 2199 _fl_set_object_shortcut(pObject, ssstr, ishowit)
2200 2201
2202 -def fl_set_object_shortcutkey(pObject, keysym):
2203 """ 2204 fl_set_object_shortcutkey(pObject, keysym) 2205 2206 @param pObject : pointer to object 2207 @param keysym : ? 2208 """ 2209 2210 _fl_set_object_shortcutkey = cfuncproto( 2211 load_so_libforms(), "fl_set_object_shortcutkey", 2212 None, [cty.POINTER(FL_OBJECT), cty.c_uint], \ 2213 """void fl_set_object_shortcutkey(FL_OBJECT * obj, 2214 unsigned int keysym) 2215 """) 2216 uikeysym = convert_to_uint(keysym) 2217 keep_elem_refs(pObject, keysym, uikeysym) 2218 _fl_set_object_shortcutkey(pObject, uikeysym)
2219 2220
2221 -def fl_set_object_dblbuffer(pObject, y):
2222 """ 2223 fl_set_object_dblbuffer(pObject, y) 2224 2225 @param pObject : pointer to object 2226 @param y : flag (0|1) to disable/enable double buffer 2227 """ 2228 2229 _fl_set_object_dblbuffer = cfuncproto( 2230 load_so_libforms(), "fl_set_object_dblbuffer", \ 2231 None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 2232 """void fl_set_object_dblbuffer(FL_OBJECT * ob, int y) 2233 """) 2234 iy = convert_to_int(y) 2235 keep_elem_refs(pObject, y, iy) 2236 _fl_set_object_dblbuffer(pObject, iy)
2237 2238
2239 -def fl_set_object_color(pObject, fgcolr, bgcolr):
2240 """ 2241 fl_set_object_color(pObject, fgcolr, bgcolr) 2242 2243 Sets the color of an object. 2244 2245 @param pObject : pointer to object 2246 @param fgcolr : foreground color 2247 @param bgcolr : background color 2248 """ 2249 2250 _fl_set_object_color = cfuncproto( 2251 load_so_libforms(), "fl_set_object_color", \ 2252 None, [cty.POINTER(FL_OBJECT), FL_COLOR, FL_COLOR], \ 2253 """void fl_set_object_color(FL_OBJECT * ob, FL_COLOR col1, 2254 FL_COLOR col2) 2255 """) 2256 check_admitted_listvalues(fgcolr, COLOR_list) 2257 check_admitted_listvalues(bgcolr, COLOR_list) 2258 ulfgcolr = convert_to_FL_COLOR(fgcolr) 2259 ulbgcolr = convert_to_FL_COLOR(bgcolr) 2260 keep_elem_refs(pObject, fgcolr, ulfgcolr, bgcolr, ulbgcolr) 2261 _fl_set_object_color(pObject, ulfgcolr, ulbgcolr)
2262 2263 2264 #def fl_set_object_color(pObject, fgcolr, bgcolr) *API change*
2265 -def fl_get_object_color(pObject):
2266 """ 2267 fl_set_object_color(pObject) -> fgcolr, bgcolr 2268 2269 Returns the foreground and background colors of an object. 2270 2271 @param pObject : pointer to object 2272 """ 2273 2274 _fl_get_object_color = cfuncproto( 2275 load_so_libforms(), "fl_get_object_color", \ 2276 None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_COLOR), \ 2277 cty.POINTER(FL_COLOR)], \ 2278 """void fl_get_object_color(FL_OBJECT * ob, FL_COLOR * col1, 2279 FL_COLOR * col2) 2280 """) 2281 fgcolr, pfgcolr = make_FL_COLOR_and_pointer() 2282 bgcolr, pbgcolr = make_FL_COLOR_and_pointer() 2283 keep_elem_refs(pObject, fgcolr, pfgcolr, bgcolr, pbgcolr) 2284 _fl_get_object_color(pObject, pfgcolr, pbgcolr) 2285 return fgcolr, bgcolr
2286 2287
2288 -def fl_set_object_label(pObject, label):
2289 """ 2290 fl_set_object_label(pObject, label) 2291 2292 Sets the label of an object. 2293 2294 @param pObject : pointer to object 2295 @param label : label of object 2296 """ 2297 2298 _fl_set_object_label = cfuncproto( 2299 load_so_libforms(), "fl_set_object_label", \ 2300 None, [cty.POINTER(FL_OBJECT), STRING], \ 2301 """void fl_set_object_label(FL_OBJECT * ob, const char * label) 2302 """) 2303 slabel = convert_to_string(label) 2304 keep_elem_refs(pObject, label, slabel) 2305 _fl_set_object_label(pObject, slabel)
2306 2307
2308 -def fl_get_object_label(pObject):
2309 """ 2310 fl_get_object_label(pObject) -> label 2311 2312 Returns the label of an object. 2313 2314 @param pObject : pointer to object 2315 """ 2316 2317 _fl_get_object_label = cfuncproto( 2318 load_so_libforms(), "fl_get_object_label", \ 2319 STRING, [cty.POINTER(FL_OBJECT)], \ 2320 """const char * fl_set_object_label(FL_OBJECT * obj) 2321 """) 2322 keep_elem_refs(pObject) 2323 retval = _fl_get_object_label(pObject) 2324 return retval
2325 2326
2327 -def fl_set_object_helper(pObject, tip):
2328 """ 2329 fl_set_object_helper(pObject, tip) 2330 2331 Sets the tooltip of an object. 2332 2333 @param pObject : pointer to object 2334 @param tip : tooltip text for object 2335 """ 2336 2337 _fl_set_object_helper = cfuncproto( 2338 load_so_libforms(), "fl_set_object_helper", \ 2339 None, [cty.POINTER(FL_OBJECT), STRING], \ 2340 """void fl_set_object_helper(FL_OBJECT * ob, const char * tip) 2341 """) 2342 stip = convert_to_string(tip) 2343 keep_elem_refs(pObject, tip, stip) 2344 _fl_set_object_helper(pObject, stip)
2345 2346
2347 -def fl_set_object_position(pObject, x, y):
2348 """ 2349 fl_set_object_position(pObject, x, y) 2350 2351 Sets position of an object. 2352 2353 @param pObject : pointer of object 2354 @param x : horizontal position 2355 @param y : vertical position 2356 """ 2357 2358 _fl_set_object_position = cfuncproto( 2359 load_so_libforms(), "fl_set_object_position", \ 2360 None, [cty.POINTER(FL_OBJECT), FL_Coord, FL_Coord], \ 2361 """void fl_set_object_position(FL_OBJECT * obj, FL_Coord x, 2362 FL_Coord y) 2363 """) 2364 ix = convert_to_FL_Coord(x) 2365 iy = convert_to_FL_Coord(y) 2366 keep_elem_refs(pObject, x, ix, y, iy) 2367 _fl_set_object_position(pObject, ix, iy)
2368 2369 2370 #def fl_get_object_size(pObject, w, h) *API change*
2371 -def fl_get_object_size(pObject):
2372 """ 2373 fl_get_object_size(pObject) -> width, height 2374 2375 Returns the size of an object. 2376 2377 @param pObject : pointer to object 2378 """ 2379 2380 _fl_get_object_size = cfuncproto( 2381 load_so_libforms(), "fl_get_object_size", \ 2382 None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_Coord), 2383 cty.POINTER(FL_Coord)], \ 2384 """void fl_get_object_size(FL_OBJECT * obj, FL_Coord * w, 2385 FL_Coord * h) 2386 """) 2387 w, pw = make_FL_Coord_and_pointer() 2388 h, ph = make_FL_Coord_and_pointer() 2389 keep_elem_refs(pObject, w, h, pw, ph) 2390 _fl_get_object_size(pObject, pw, ph) 2391 return w, h
2392 2393
2394 -def fl_set_object_size(pObject, w, h):
2395 """ 2396 fl_set_object_size(pObject, w, h) 2397 2398 Sets the size of an object. 2399 2400 @param pObject : pointer to object 2401 @param w : width of object 2402 @param h : height of object 2403 """ 2404 2405 _fl_set_object_size = cfuncproto( 2406 load_so_libforms(), "fl_set_object_size", \ 2407 None, [cty.POINTER(FL_OBJECT), FL_Coord, FL_Coord], \ 2408 """void fl_set_object_size(FL_OBJECT * obj, FL_Coord w, 2409 FL_Coord h) 2410 """) 2411 iw = convert_to_FL_Coord(w) 2412 ih = convert_to_FL_Coord(h) 2413 keep_elem_refs(pObject, w, iw, h, ih) 2414 _fl_set_object_size(pObject, iw, ih)
2415 2416
2417 -def fl_set_object_automatic(pObject, flag):
2418 """ 2419 fl_set_object_automatic(pObject, flag) 2420 2421 @param pObject : pointer to object 2422 @param flag : flag (0|1) 2423 """ 2424 2425 _fl_set_object_automatic = cfuncproto( 2426 load_so_libforms(), "fl_set_object_automatic", 2427 None, [cty.POINTER(FL_OBJECT), cty.c_int], \ 2428 """void fl_set_object_automatic(FL_OBJECT * ob, int flag) 2429 """) 2430 iflag = convert_to_int(flag) 2431 keep_elem_refs(pObject, flag, iflag) 2432 _fl_set_object_automatic(pObject, iflag)
2433 2434
2435 -def fl_object_is_automatic(pObject):
2436 """ 2437 fl_object_is_automatic(pObject) -> flag num. 2438 2439 @param pObject : pointer to object 2440 """ 2441 2442 _fl_object_is_automatic = cfuncproto( 2443 load_so_libforms(), "fl_object_is_automatic", 2444 cty.c_int, [cty.POINTER(FL_OBJECT)], \ 2445 """int fl_object_is_automatic(FL_OBJECT * obj) 2446 """) 2447 keep_elem_refs(pObject) 2448 retval = _fl_object_is_automatic(pObject) 2449 return retval
2450 2451
2452 -def fl_draw_object_label(pObject):
2453 """ 2454 fl_draw_object_label(pObject) 2455 2456 @param pObject : pointer to object 2457 """ 2458 2459 _fl_draw_object_label = cfuncproto( 2460 load_so_libforms(), "fl_draw_object_label", \ 2461 None, [cty.POINTER(FL_OBJECT)], \ 2462 """void fl_draw_object_label(FL_OBJECT * ob) 2463 """) 2464 keep_elem_refs(pObject) 2465 _fl_draw_object_label(pObject)
2466 2467
2468 -def fl_draw_object_label_outside(pObject):
2469 """ 2470 fl_draw_object_label_outside(pObject) 2471 2472 @param pObject : pointer to object 2473 """ 2474 2475 _fl_draw_object_label_outside = cfuncproto( 2476 load_so_libforms(), "fl_draw_object_label_outside", 2477 None, [cty.POINTER(FL_OBJECT)], \ 2478 """void fl_draw_object_label_outside(FL_OBJECT * ob) 2479 """) 2480 keep_elem_refs(pObject) 2481 _fl_draw_object_label_outside(pObject)
2482 2483
2484 -def fl_get_object_component(pObjectComposite, objclass, compontype, numb):
2485 """ fl_get_object_component(pObjectComposite, objclass, compontype, numb) -> pObject 2486 """ 2487 2488 _fl_get_object_component = cfuncproto( 2489 load_so_libforms(), "fl_get_object_component", 2490 cty.POINTER(FL_OBJECT), [cty.POINTER(FL_OBJECT), cty.c_int, 2491 cty.c_int, cty.c_int], \ 2492 """FL_OBJECT * fl_get_object_component(FL_OBJECT * composite, 2493 int objclass, int type, int numb) 2494 """) 2495 iobjclass = convert_to_int(objclass) 2496 icompontype = convert_to_int(compontype) 2497 inumb = convert_to_int(numb) 2498 keep_elem_refs(pObjectComposite, objclass, iobjclass, compontype, \ 2499 icompontype, numb, inumb) 2500 retval = _fl_get_object_component(pObjectComposite, iobjclass, \ 2501 icompontype, inumb) 2502 return retval
2503 2504 2505 # cfunction for _fl_for_all_objects 2506 cfunc_int_pobject_pvoid = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT), \ 2507 cty.c_void_p) 2508
2509 -def fl_for_all_objects(pForm, py_cb, v):
2510 """ 2511 fl_for_all_objects(pForm, py_cb, v) 2512 2513 @param pForm : pointer to form 2514 @param py_cb : python function, fn(pObject, ptr_void) -> num. 2515 @param v : argument 2516 """ 2517 2518 _fl_for_all_objects = cfuncproto( 2519 load_so_libforms(), "fl_for_all_objects", \ 2520 None, [cty.POINTER(FL_FORM), cfunc_int_pobject_pvoid, \ 2521 cty.c_void_p], \ 2522 """void fl_for_all_objects(FL_FORM * form, int ( * cb ) \ 2523 ( FL_OBJECT *, void * ), void * v) 2524 """) 2525 c_cb = cfunc_int_pobject_pvoid(py_cb) 2526 pv = cty.cast(v, cty.c_void_p) 2527 keep_cfunc_refs(c_cb, py_cb) 2528 keep_elem_refs(pForm, v, pv) 2529 _fl_for_all_objects(pForm, c_cb, pv)
2530 2531 2532 fl_draw_object_outside_label = fl_draw_object_label_outside 2533 2534
2535 -def fl_set_object_dblclick(pObject, timeout):
2536 pObject.contents.click_timeout = timeout
2537 2538
2539 -def fl_set_object_geometry(pObject, x, y, w, h):
2540 """ 2541 fl_set_object_geometry(pObject, x, y, w, h) 2542 2543 Sets the geometry (position and size) of an object. 2544 2545 @param pObject : pointer to object 2546 @param x : horizontal position (upper-left corner) 2547 @param y : vertical position (upper-left corner) 2548 @param w : width of the object in pixels 2549 @param h : height of the object in pixels 2550 """ 2551 2552 _fl_set_object_geometry = cfuncproto( 2553 load_so_libforms(), "fl_set_object_geometry", \ 2554 None, [cty.POINTER(FL_OBJECT), FL_Coord, FL_Coord, FL_Coord, 2555 FL_Coord], \ 2556 """void fl_set_object_geometry(FL_OBJECT * obj, FL_Coord x, 2557 FL_Coord y, FL_Coord w, FL_Coord h) 2558 """) 2559 ix = convert_to_FL_Coord(x) 2560 iy = convert_to_FL_Coord(y) 2561 iw = convert_to_FL_Coord(w) 2562 ih = convert_to_FL_Coord(h) 2563 keep_elem_refs(pObject, x, ix, y, iy, w, iw, h, ih) 2564 _fl_set_object_geometry(pObject, ix, iy, iw, ih)
2565 2566
2567 -def fl_move_object(pObject, dx, dy):
2568 """ 2569 fl_move_object(pObject, dx, dy) 2570 2571 @param pObject : pointer to object 2572 """ 2573 2574 _fl_move_object = cfuncproto( 2575 load_so_libforms(), "fl_move_object", \ 2576 None, [cty.POINTER(FL_OBJECT), FL_Coord, FL_Coord], \ 2577 """void fl_move_object(FL_OBJECT * obj, FL_Coord dx, FL_Coord dy) 2578 """) 2579 idx = convert_to_int(dx) 2580 idy = convert_to_int(dy) 2581 keep_elem_refs(pObject, dx, idx, dy, idy) 2582 _fl_move_object(pObject, idx, idy)
2583 2584 2585 fl_set_object_lcolor = fl_set_object_lcol 2586 2587
2588 -def fl_fit_object_label(pObject, xmargin, ymargin):
2589 """ 2590 fl_fit_object_label(pObject, xmargin, ymargin) 2591 2592 Checks if the label of an object fits into it (after x- and 2593 y-margin have been added). If not, all objects and the form 2594 are enlarged by the necessary factor (but never by more than 2595 a factor of 1.5) 2596 2597 @param pObject : pointer to object 2598 @param xmargin : horizontal margin 2599 @param ymargin : vertical margin 2600 """ 2601 2602 _fl_fit_object_label = cfuncproto( 2603 load_so_libforms(), "fl_fit_object_label",\ 2604 None, [cty.POINTER(FL_OBJECT), FL_Coord, FL_Coord],\ 2605 """void fl_fit_object_label(FL_OBJECT * obj, FL_Coord xmargin, 2606 FL_Coord ymargin) 2607 """) 2608 ixmargin = convert_to_int(xmargin) 2609 iymargin = convert_to_int(ymargin) 2610 keep_elem_refs(pObject, xmargin, ixmargin, ymargin, iymargin) 2611 _fl_fit_object_label(pObject, ixmargin, iymargin)
2612 2613 2614 #def fl_get_object_geometry(pObject, x, y, w, h) *API change*
2615 -def fl_get_object_geometry(pObject):
2616 """ 2617 fl_get_object_geometry(pObject) -> hor-xpos, vert-ypos, width, height 2618 2619 Returns the geometry (position and size) of an object. 2620 2621 @param pObject : pointer to object 2622 """ 2623 2624 _fl_get_object_geometry = cfuncproto( 2625 load_so_libforms(), "fl_get_object_geometry",\ 2626 None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_Coord),\ 2627 cty.POINTER(FL_Coord), cty.POINTER(FL_Coord), cty.POINTER(FL_Coord)], 2628 """void fl_get_object_geometry(FL_OBJECT * ob, FL_Coord * x, 2629 FL_Coord * y, FL_Coord * w, FL_Coord * h) 2630 """) 2631 x, px = make_FL_Coord_and_pointer() 2632 y, py = make_FL_Coord_and_pointer() 2633 w, pw = make_FL_Coord_and_pointer() 2634 h, ph = make_FL_Coord_and_pointer() 2635 keep_elem_refs(pObject, x, px, y, py, w, pw, h, ph) 2636 _fl_get_object_geometry(pObject, px, py, pw, ph) 2637 return x, y, w,h
2638 2639 2640 #def fl_get_object_position(pObject, x, y) *API change*
2641 -def fl_get_object_position(pObject):
2642 """ 2643 fl_get_object_position(pObject) -> xpos, ypos 2644 2645 Returns the position of an object. 2646 2647 @param pObject : pointer to object 2648 """ 2649 2650 _fl_get_object_position = cfuncproto( 2651 load_so_libforms(), "fl_get_object_position",\ 2652 None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_Coord), 2653 cty.POINTER(FL_Coord)],\ 2654 """void fl_get_object_position(FL_OBJECT * ob, FL_Coord * x, 2655 FL_Coord * y) 2656 """) 2657 x, px = make_FL_Coord_and_pointer() 2658 y, py = make_FL_Coord_and_pointer() 2659 keep_elem_refs(pObject, x, px, y, py) 2660 _fl_get_object_position(pObject, px, py) 2661 return x,y
2662 2663 2664 # this one takes into account the label 2665 2666 #def fl_get_object_bbox(pObject, x, y, w, h) *API change*
2667 -def fl_get_object_bbox(pObject):
2668 """ 2669 fl_get_object_bbox(pObject) -> x, y, w, h 2670 2671 @param pObject : pointer to object 2672 """ 2673 2674 _fl_get_object_bbox = cfuncproto( 2675 load_so_libforms(), "fl_get_object_bbox",\ 2676 None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_Coord),\ 2677 cty.POINTER(FL_Coord), cty.POINTER(FL_Coord), 2678 cty.POINTER(FL_Coord)],\ 2679 """void fl_get_object_bbox(FL_OBJECT * obj, FL_Coord * x, 2680 FL_Coord * y, FL_Coord * w, FL_Coord * h) 2681 """) 2682 x, px = make_FL_Coord_and_pointer() 2683 y, py = make_FL_Coord_and_pointer() 2684 w, pw = make_FL_Coord_and_pointer() 2685 h, ph = make_FL_Coord_and_pointer() 2686 keep_elem_refs(pObject, x, y, w, h, px, py, pw, ph) 2687 _fl_get_object_bbox(pObject, px, py, pw, ph) 2688 return x, y, w,h
2689 2690 2691 fl_compute_object_geometry = fl_get_object_bbox 2692 2693
2694 -def fl_call_object_callback(pObject):
2695 """ 2696 fl_call_object_callback(pObject) 2697 2698 @param pObject : pointer to object 2699 """ 2700 2701 _fl_call_object_callback = cfuncproto( 2702 load_so_libforms(), "fl_call_object_callback",\ 2703 None, [cty.POINTER(FL_OBJECT)],\ 2704 """void fl_call_object_callback(FL_OBJECT * ob) 2705 """) 2706 keep_elem_refs(pObject) 2707 _fl_call_object_callback(pObject)
2708 2709 2710 #already defined in xfdata 2711 #FL_HANDLEPTR = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT), cty.c_int, \ 2712 # FL_Coord, FL_Coord, cty.c_int, cty.c_void_p) 2713
2714 -def fl_set_object_prehandler(pObject, py_HandlerPtr):
2715 """ 2716 fl_set_object_prehandler(pObject, py_HandlerPtr) -> pHandlerPtr 2717 2718 @param pObject : pointer to object 2719 @param py_HandlerPtr : python callback function, fn(pObject, 2720 num, coord, coord, num, ptr_void) -> num 2721 """ 2722 2723 _fl_set_object_prehandler = cfuncproto( 2724 load_so_libforms(), "fl_set_object_prehandler", 2725 FL_HANDLEPTR, [cty.POINTER(FL_OBJECT), FL_HANDLEPTR],\ 2726 """FL_HANDLEPTR fl_set_object_prehandler(FL_OBJECT * ob, 2727 FL_HANDLEPTR phandler) 2728 """) 2729 c_HandlerPtr = FL_HANDLEPTR(py_HandlerPtr) 2730 keep_cfunc_refs(c_HandlerPtr, py_HandlerPtr) 2731 keep_elem_refs(pObject) 2732 retval = _fl_set_object_prehandler(pObject, c_HandlerPtr) 2733 return retval
2734 2735
2736 -def fl_set_object_posthandler(pObject, py_HandlerPtr):
2737 """ 2738 fl_set_object_posthandler(pObject, py_HandlerPtr) -> pHandlerPtr 2739 2740 @param pObject : pointer to object 2741 @param py_HandlerPtr : python callback function, fn(pObject, 2742 num, coord, coord, num, ptr_void) -> num 2743 """ 2744 2745 _fl_set_object_posthandler = cfuncproto( 2746 load_so_libforms(), "fl_set_object_posthandler", 2747 FL_HANDLEPTR, [cty.POINTER(FL_OBJECT), FL_HANDLEPTR],\ 2748 """FL_HANDLEPTR fl_set_object_posthandler(FL_OBJECT * ob, 2749 FL_HANDLEPTR post) 2750 """) 2751 c_HandlerPtr = FL_HANDLEPTR(py_HandlerPtr) 2752 keep_cfunc_refs(c_HandlerPtr, py_HandlerPtr) 2753 keep_elem_refs(pObject) 2754 retval = _fl_set_object_posthandler(pObject, c_HandlerPtr) 2755 return retval
2756 2757 2758 #already defined in xfdata 2759 #FL_CALLBACKPTR = cty.CFUNCTYPE(None, cty.POINTER(FL_OBJECT), cty.c_long) 2760
2761 -def fl_set_object_callback(pObject, py_CallbackPtr, argum):
2762 """ 2763 fl_set_object_callback(pObject, py_CallbackPtr, argum) -> c_callback func. 2764 2765 Calls a callback function bound to an object, if a condition is met. 2766 2767 @param pObject : pointer to object 2768 @param py_CallbackPtr : a python function with no () and no args to 2769 be used as callback, fn(pObject, longnum) 2770 @param argum : argument being passed to function 2771 """ 2772 2773 _fl_set_object_callback = cfuncproto( 2774 load_so_libforms(), "fl_set_object_callback",\ 2775 FL_CALLBACKPTR, [cty.POINTER(FL_OBJECT), FL_CALLBACKPTR, 2776 cty.c_long], 2777 """FL_CALLBACKPTR fl_set_object_callback(FL_OBJECT * obj,\ 2778 FL_CALLBACKPTR callback, long int argument) 2779 """) 2780 largum = convert_to_long(argum) 2781 c_CallbackPtr = FL_CALLBACKPTR(py_CallbackPtr) 2782 keep_cfunc_refs(c_CallbackPtr, py_CallbackPtr) 2783 keep_elem_refs(pObject, argum, largum) 2784 retval = _fl_set_object_callback(pObject, c_CallbackPtr, largum) 2785 return retval
2786 2787 2788 fl_set_object_align = fl_set_object_lalign 2789 fl_set_call_back = fl_set_object_callback 2790 2791
2792 -def fl_redraw_object(pObject):
2793 """ 2794 fl_redraw_object(pObject) 2795 2796 @param pObject : pointer to object 2797 """ 2798 2799 _fl_redraw_object = cfuncproto( 2800 load_so_libforms(), "fl_redraw_object",\ 2801 None, [cty.POINTER(FL_OBJECT)],\ 2802 """void fl_redraw_object(FL_OBJECT * obj) 2803 """) 2804 keep_elem_refs(pObject) 2805 _fl_redraw_object(pObject)
2806 2807
2808 -def fl_scale_object(pObject, xs, ys):
2809 """ 2810 fl_scale_object(pObject, xs, ys) 2811 2812 Scales (shrink or enlarge) an object. 2813 2814 @param pObject : pointer to object 2815 @param xs : new horizontal factor 2816 @param ys : new vertical factor 2817 """ 2818 2819 _fl_scale_object = cfuncproto( 2820 load_so_libforms(), "fl_scale_object",\ 2821 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double],\ 2822 """void fl_scale_object(FL_OBJECT * ob, double xs, double ys) 2823 """) 2824 fxs = convert_to_double(xs) 2825 fys = convert_to_double(ys) 2826 keep_elem_refs(pObject, xs, fxs, ys, fys) 2827 _fl_scale_object(pObject, fxs, fys)
2828 2829
2830 -def fl_show_object(pObject):
2831 """ 2832 fl_show_object(pObject) 2833 2834 @param pObject : pointer to object 2835 """ 2836 2837 _fl_show_object = cfuncproto( 2838 load_so_libforms(), "fl_show_object",\ 2839 None, [cty.POINTER(FL_OBJECT)],\ 2840 """void fl_show_object(FL_OBJECT * ob) 2841 """) 2842 keep_elem_refs(pObject) 2843 _fl_show_object(pObject)
2844 #pObject.contents.visible = 1 2845 2846
2847 -def fl_hide_object(pObject):
2848 """ 2849 fl_hide_object(pObject) 2850 2851 @param pObject : pointer to object 2852 """ 2853 2854 _fl_hide_object = cfuncproto( 2855 load_so_libforms(), "fl_hide_object",\ 2856 None, [cty.POINTER(FL_OBJECT)],\ 2857 """void fl_hide_object(FL_OBJECT * ob) 2858 """) 2859 keep_elem_refs(pObject) 2860 _fl_hide_object(pObject)
2861 #pObject.contents.visible = 0 2862 2863
2864 -def fl_object_is_visible(pObject):
2865 """ 2866 fl_object_is_visible(pObject) -> num. 2867 2868 @param pObject : pointer to object 2869 """ 2870 2871 _fl_object_is_visible = cfuncproto( 2872 load_so_libforms(), "fl_object_is_visible",\ 2873 cty.c_int, [cty.POINTER(FL_OBJECT)],\ 2874 """int fl_object_is_visible(FL_OBJECT * obj) 2875 """) 2876 keep_elem_refs(pObject) 2877 retval = _fl_object_is_visible(pObject) 2878 return retval
2879 2880
2881 -def fl_free_object(pObject):
2882 """ 2883 fl_free_object(pObject) 2884 2885 @param pObject : pointer to object 2886 """ 2887 2888 _fl_free_object = cfuncproto( 2889 load_so_libforms(), "fl_free_object",\ 2890 None, [cty.POINTER(FL_OBJECT)],\ 2891 """void fl_free_object(FL_OBJECT * obj) 2892 """) 2893 keep_elem_refs(pObject) 2894 _fl_free_object(pObject)
2895 2896
2897 -def fl_delete_object(pObject):
2898 """ 2899 fl_delete_object(pObject) 2900 2901 @param pObject : pointer to object 2902 """ 2903 2904 _fl_delete_object = cfuncproto( 2905 load_so_libforms(), "fl_delete_object",\ 2906 None, [cty.POINTER(FL_OBJECT)],\ 2907 """void fl_delete_object(FL_OBJECT * obj) 2908 """) 2909 keep_elem_refs(pObject) 2910 _fl_delete_object(pObject)
2911 2912
2913 -def fl_get_object_return_state(pObject):
2914 """ 2915 fl_get_object_return_state(pObject) -> ID num 2916 2917 @param pObject : pointer to object 2918 """ 2919 2920 _fl_get_object_return_state = cfuncproto( 2921 load_so_libforms(), "fl_get_object_return_state", 2922 cty.c_int, [cty.POINTER(FL_OBJECT)],\ 2923 """int fl_get_object_return_state(FL_OBJECT * obj) 2924 """) 2925 keep_elem_refs(pObject) 2926 retval = _fl_get_object_return_state(pObject) 2927 return retval
2928 2929
2930 -def fl_trigger_object(pObject):
2931 """ 2932 fl_trigger_object(pObject) 2933 2934 @param pObject : pointer to object 2935 """ 2936 2937 _fl_trigger_object = cfuncproto( 2938 load_so_libforms(), "fl_trigger_object",\ 2939 None, [cty.POINTER(FL_OBJECT)],\ 2940 """void fl_trigger_object(FL_OBJECT * obj) 2941 """) 2942 keep_elem_refs(pObject) 2943 _fl_trigger_object(pObject)
2944 2945
2946 -def fl_activate_object(pObject):
2947 """ 2948 fl_activate_object(pObject) 2949 2950 @param pObject : pointer to object 2951 """ 2952 2953 _fl_activate_object = cfuncproto( 2954 load_so_libforms(), "fl_activate_object",\ 2955 None, [cty.POINTER(FL_OBJECT)],\ 2956 """void fl_activate_object(FL_OBJECT * ob) 2957 """) 2958 keep_elem_refs(pObject) 2959 _fl_activate_object(pObject)
2960 #pObject.contents.active = 1 2961 2962
2963 -def fl_deactivate_object(pObject):
2964 """ 2965 fl_deactivate_object(pObject) 2966 2967 @param pObject : pointer to object 2968 """ 2969 2970 _fl_deactivate_object = cfuncproto( 2971 load_so_libforms(), "fl_deactivate_object",\ 2972 None, [cty.POINTER(FL_OBJECT)],\ 2973 """void fl_deactivate_object(FL_OBJECT * ob) 2974 """) 2975 keep_elem_refs(pObject) 2976 _fl_deactivate_object(pObject)
2977 #pObject.contents.active = 0 2978 2979
2980 -def fl_object_is_active(pObject):
2981 """ 2982 fl_object_is_active(pObject) -> num. 2983 2984 @param pObject : pointer to object 2985 """ 2986 2987 _fl_object_is_active = cfuncproto( 2988 load_so_libforms(), "fl_object_is_active",\ 2989 cty.c_int, [cty.POINTER(FL_OBJECT)],\ 2990 """int fl_object_is_active(FL_OBJECT * ob) 2991 """) 2992 keep_elem_refs(pObject) 2993 retval = _fl_object_is_active(pObject) 2994 return retval
2995 2996 2997 # cfunction for _fl_enumerate_fonts 2998 cfunc_none_string = cty.CFUNCTYPE(None, STRING) 2999
3000 -def fl_enumerate_fonts(py_output, shortform):
3001 """ fl_enumerate_fonts(py_output, shortform) -> ID num 3002 """ 3003 3004 _fl_enumerate_fonts = cfuncproto( 3005 load_so_libforms(), "fl_enumerate_fonts",\ 3006 cty.c_int, [cfunc_none_string, cty.c_int],\ 3007 """int fl_enumerate_fonts(void ( * output )( const char *s ), \ 3008 int shortform) 3009 """) 3010 ishortform = convert_to_int(shortform) 3011 c_output = cfunc_none_string(py_output) 3012 keep_cfunc_refs(c_output, py_output) 3013 keep_elem_refs(shortform, ishortform) 3014 retval = _fl_enumerate_fonts(c_output, ishortform) 3015 return retval
3016 3017
3018 -def fl_set_font_name(n, name):
3019 """ fl_set_font_name(n, name) -> ID num 3020 """ 3021 3022 _fl_set_font_name = cfuncproto( 3023 load_so_libforms(), "fl_set_font_name",\ 3024 cty.c_int, [cty.c_int, STRING],\ 3025 """int fl_set_font_name(int n, const char * name) 3026 """) 3027 inum = convert_to_int(n) 3028 sname = convert_to_string(name) 3029 keep_elem_refs(n, inum, name, sname) 3030 retval = _fl_set_font_name(inum, sname) 3031 return retval
3032 3033
3034 -def fl_set_font(numb, size):
3035 """ fl_set_font(numb, size) 3036 """ 3037 3038 _fl_set_font = cfuncproto( 3039 load_so_libforms(), "fl_set_font",\ 3040 None, [cty.c_int, cty.c_int],\ 3041 """void fl_set_font(int numb, int size) 3042 """) 3043 inumb = convert_to_int(numb) 3044 isize = convert_to_int(size) 3045 keep_elem_refs(numb, inumb, size, isize) 3046 _fl_set_font(inumb, isize)
3047 3048 3049 # routines that facilitate free object 3050 3051 #def fl_get_char_height(style, size, asc, desc) *API change*
3052 -def fl_get_char_height(style, size):
3053 """ fl_get_char_height(style, size) -> height num., asc, desc 3054 """ 3055 3056 _fl_get_char_height = cfuncproto( 3057 load_so_libforms(), "fl_get_char_height",\ 3058 cty.c_int, [cty.c_int, cty.c_int, cty.POINTER(cty.c_int), 3059 cty.POINTER(cty.c_int)],\ 3060 """int fl_get_char_height(int style, int size, int * asc, 3061 int * desc) 3062 """) 3063 istyle = convert_to_int(style) 3064 isize = convert_to_int(size) 3065 asc, pasc = make_int_and_pointer() # not sure 3066 desc, pdesc = make_int_and_pointer() 3067 keep_elem_refs(style, istyle, size, isize, asc, desc, pasc, pdesc) 3068 retval = _fl_get_char_height(istyle, isize, pasc, pdesc) 3069 return retval, asc, desc
3070 3071
3072 -def fl_get_char_width(style, size):
3073 """ fl_get_char_width(style, size) -> width num. 3074 """ 3075 3076 _fl_get_char_width = cfuncproto( 3077 load_so_libforms(), "fl_get_char_width",\ 3078 cty.c_int, [cty.c_int, cty.c_int],\ 3079 """int fl_get_char_width(int style, int size) 3080 """) 3081 istyle = convert_to_int(style) 3082 isize = convert_to_int(size) 3083 keep_elem_refs(style, istyle, size, isize) 3084 retval = _fl_get_char_width(istyle, isize) 3085 return retval
3086 3087 3088 #def fl_get_string_height(style, size, strng, strglen, asc, desc) *API change*
3089 -def fl_get_string_height(style, size, strng, strglen):
3090 """ fl_get_string_height(style, size, strng, strglen) -> height num., asc, desc 3091 """ 3092 3093 _fl_get_string_height = cfuncproto( 3094 load_so_libforms(), "fl_get_string_height",\ 3095 cty.c_int, [cty.c_int, cty.c_int, STRING, cty.c_int, 3096 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)],\ 3097 """int fl_get_string_height(int style, int size, const char * s, 3098 int len, int * asc, int * desc) 3099 """) 3100 istyle = convert_to_int(style) 3101 isize = convert_to_int(size) 3102 sstrng = convert_to_string(strng) 3103 istrglen = convert_to_int(strglen) 3104 #pasc = cty.cast(asc, cty.POINTER(cty.c_int)) 3105 asc, pasc = make_int_and_pointer() 3106 #pdesc = cty.cast(desc, cty.POINTER(cty.c_int)) 3107 desc, pdesc = make_int_and_pointer() 3108 keep_elem_refs(style, istyle, size, isize, strng, sstrng, strglen,\ 3109 istrglen, asc, desc, pasc, pdesc) 3110 retval = _fl_get_string_height(istyle, isize, sstrng, istrglen,\ 3111 pasc, pdesc) 3112 return retval, asc, desc
3113 3114
3115 -def fl_get_string_width(style, size, s, strglen):
3116 """ fl_get_string_width(style, size, s, strglen) -> width num. 3117 """ 3118 3119 _fl_get_string_width = cfuncproto( 3120 load_so_libforms(), "fl_get_string_width",\ 3121 cty.c_int, [cty.c_int, cty.c_int, STRING, cty.c_int],\ 3122 """int fl_get_string_width(int style, int size, const char * s, 3123 int len) 3124 """) 3125 istyle = convert_to_int(style) 3126 isize = convert_to_int(size) 3127 ss = convert_to_string(s) 3128 istrglen = convert_to_int(strglen) 3129 keep_elem_refs(style, istyle, size, isize, s, ss, strglen, istrglen) 3130 retval = _fl_get_string_width(istyle, isize, ss, istrglen) 3131 return retval
3132 3133
3134 -def fl_get_string_widthTAB(style, size, s, strglen):
3135 """ fl_get_string_widthTAB(style, size, s, strglen) -> width num. 3136 """ 3137 3138 _fl_get_string_widthTAB = cfuncproto( 3139 load_so_libforms(), "fl_get_string_widthTAB",\ 3140 cty.c_int, [cty.c_int, cty.c_int, STRING, cty.c_int],\ 3141 """int fl_get_string_widthTAB(int style, int size, const char * s, 3142 int len) 3143 """) 3144 istyle = convert_to_int(style) 3145 isize = convert_to_int(size) 3146 ss = convert_to_string(s) 3147 istrglen = convert_to_int(strglen) 3148 keep_elem_refs(style, istyle, size, isize, s, ss, strglen, istrglen) 3149 retval = _fl_get_string_widthTAB(istyle, isize, ss, istrglen) 3150 return retval
3151 3152 3153 #def fl_get_string_dimension(fntstyle, fntsize, s, strglen, width, height) *API change*
3154 -def fl_get_string_dimension(fntstyle, fntsize, s, strglen):
3155 """ fl_get_string_dimension(fntstyle, fntsize, s, strglen) -> width, height 3156 """ 3157 3158 _fl_get_string_dimension = cfuncproto( 3159 load_so_libforms(), "fl_get_string_dimension",\ 3160 None, [cty.c_int, cty.c_int, STRING, cty.c_int, 3161 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)],\ 3162 """void fl_get_string_dimension(int fntstyle, int fntsize, 3163 const char * s, int len, int * width, int * height) 3164 """) 3165 ifntstyle = convert_to_int(fntstyle) 3166 ifntsize = convert_to_int(fntsize) 3167 ss = convert_to_string(s) 3168 istrglen = convert_to_int(strglen) 3169 width, pwidth = make_int_and_pointer() 3170 height, pheight = make_int_and_pointer() 3171 keep_elem_refs(fntstyle, ifntstyle, fntsize, ifntsize, s, ss, strglen, 3172 istrglen, width, height, pwidth, pheight) 3173 _fl_get_string_dimension(ifntstyle, ifntsize, ss, istrglen, pwidth, 3174 pheight) 3175 return width, height
3176 3177 3178 fl_get_string_size = fl_get_string_dimension 3179 3180 3181 #def fl_get_align_xy(align, x, y, w, h, xsize, ysize, xoff, yoff, xx, yy) *API change*
3182 -def fl_get_align_xy(align, x, y, w, h, xsize, ysize, xoff, yoff):
3183 """ fl_get_align_xy(align, x, y, w, h, xsize, ysize, xoff, yoff) -> xx, yy 3184 """ 3185 3186 _fl_get_align_xy = cfuncproto( 3187 load_so_libforms(), "fl_get_align_xy",\ 3188 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int,\ 3189 cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.POINTER(cty.c_int),\ 3190 cty.POINTER(cty.c_int)],\ 3191 """void fl_get_align_xy(int align, int x, int y, int w, int h, 3192 int xsize, int ysize, int xoff, int yoff, int * xx, int * yy) 3193 """) 3194 check_admitted_listvalues(align, ALIGN_list) 3195 ialign = convert_to_int(align) 3196 ix = convert_to_int(x) 3197 iy = convert_to_int(y) 3198 iw = convert_to_int(w) 3199 ih = convert_to_int(h) 3200 ixsize = convert_to_int(xsize) 3201 iysize = convert_to_int(ysize) 3202 ixoff = convert_to_int(xoff) 3203 iyoff = convert_to_int(yoff) 3204 xx, pxx = make_int_and_pointer() 3205 yy, pyy = make_int_and_pointer() 3206 keep_elem_refs(align, ialign, x, ix, y, iy, w, iw, h, ih, xsize, ixsize, 3207 ysize, iysize, xoff, ixoff, yoff, iyoff, xx, yy, pxx, pyy) 3208 _fl_get_align_xy(ialign, ix, iy, iw, ih, ixsize, iysize, ixoff, 3209 iyoff, pxx, pyy) 3210 return xx, yy
3211 3212
3213 -def fl_drw_text(align, x, y, w, h, colr, style, size, txtstr):
3214 """ fl_drw_text(align, x, y, w, h, colr, style, size, txtstr) 3215 """ 3216 3217 _fl_drw_text = cfuncproto( 3218 load_so_libforms(), "fl_drw_text",\ 3219 None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, FL_COLOR, 3220 cty.c_int, cty.c_int, STRING],\ 3221 """void fl_drw_text(int align, FL_Coord x, FL_Coord y, FL_Coord w, 3222 FL_Coord h, FL_COLOR c, int style, int size, const char * istr) 3223 """) 3224 check_admitted_listvalues(align, ALIGN_list) 3225 ialign = convert_to_int(align) 3226 ix = convert_to_FL_Coord(x) 3227 iy = convert_to_FL_Coord(y) 3228 iw = convert_to_FL_Coord(w) 3229 ih = convert_to_FL_Coord(h) 3230 ulcolr = convert_to_FL_COLOR(colr) 3231 istyle = convert_to_int(style) 3232 isize = convert_to_int(size) 3233 s_txtstr = convert_to_string(txtstr) 3234 keep_elem_refs(align, ialign, x, ix, y, iy, w, iw, h, ih, colr, 3235 ulcolr, style, istyle, size, isize, txtstr, s_txtstr) 3236 _fl_drw_text(ialign, ix, iy, iw, ih, ulcolr, istyle, isize, 3237 s_txtstr)
3238 3239
3240 -def fl_drw_text_beside(align, x, y, w, h, colr, style, size, txtstr):
3241 """ fl_drw_text_beside(align, x, y, w, h, colr, style, size, txtstr) 3242 """ 3243 3244 _fl_drw_text_beside = cfuncproto( 3245 load_so_libforms(), "fl_drw_text_beside",\ 3246 None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, FL_COLOR, 3247 cty.c_int, cty.c_int, STRING],\ 3248 """void fl_drw_text_beside(int align, FL_Coord x, FL_Coord y, 3249 FL_Coord w, FL_Coord h, FL_COLOR c, int style, int size, 3250 const char * str) 3251 """) 3252 check_admitted_listvalues(align, ALIGN_list) 3253 ialign = convert_to_int(align) 3254 ix = convert_to_FL_Coord(x) 3255 iy = convert_to_FL_Coord(y) 3256 iw = convert_to_FL_Coord(w) 3257 ih = convert_to_FL_Coord(h) 3258 ulcolr = convert_to_FL_COLOR(colr) 3259 istyle = convert_to_int(style) 3260 isize = convert_to_int(size) 3261 s_txtstr = convert_to_string(txtstr) 3262 keep_elem_refs(align, ialign, x, ix, y, iy, w, iw, h, ih, colr, 3263 ulcolr, style, istyle, size, isize, txtstr, s_txtstr) 3264 _fl_drw_text_beside(ialign, ix, iy, iw, ih, ulcolr, istyle, 3265 isize, s_txtstr)
3266 3267
3268 -def fl_drw_text_cursor(align, x, y, w, h, colr, style, size, txtstr, cc, pos):
3269 """ fl_drw_text_cursor(align, x, y, w, h, colr, style, size, txtstr, cc, pos) 3270 """ 3271 3272 _fl_drw_text_cursor = cfuncproto( 3273 load_so_libforms(), "fl_drw_text_cursor",\ 3274 None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord,\ 3275 FL_COLOR, cty.c_int, cty.c_int, STRING, cty.c_int, cty.c_int],\ 3276 """void fl_drw_text_cursor(int align, FL_Coord x, FL_Coord y, 3277 FL_Coord w, FL_Coord h, FL_COLOR c, int style, int size, 3278 const char * str, int cc, int pos) 3279 """) 3280 check_admitted_listvalues(align, ALIGN_list) 3281 ialign = convert_to_int(align) 3282 ix = convert_to_FL_Coord(x) 3283 iy = convert_to_FL_Coord(y) 3284 iw = convert_to_FL_Coord(w) 3285 ih = convert_to_FL_Coord(h) 3286 ulcolr = convert_to_FL_COLOR(colr) 3287 istyle = convert_to_int(style) 3288 isize = convert_to_int(size) 3289 s_txtstr = convert_to_string(txtstr) 3290 icc = convert_to_int(cc) 3291 ipos = convert_to_int(pos) 3292 keep_elem_refs(align, ialign, x, ix, y, iy, w, iw, h, ih, colr, 3293 ulcolr, style, istyle, size, isize, txtstr, s_txtstr, 3294 cc, icc, pos, ipos) 3295 _fl_drw_text_cursor(ialign, ix, iy, iw, ih, ulcolr, istyle, 3296 isize, s_txtstr, icc, ipos)
3297 3298
3299 -def fl_drw_box(style, x, y, w, h, colr, bwIn):
3300 """ fl_drw_box(style, x, y, w, h, colr, bwIn) 3301 """ 3302 3303 _fl_drw_box = cfuncproto( 3304 load_so_libforms(), "fl_drw_box",\ 3305 None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, FL_COLOR, 3306 cty.c_int],\ 3307 """void fl_drw_box(int style, FL_Coord x, FL_Coord y, FL_Coord w, 3308 FL_Coord h, FL_COLOR c, int bw_in) 3309 """) 3310 istyle = convert_to_int(style) 3311 ix = convert_to_FL_Coord(x) 3312 iy = convert_to_FL_Coord(y) 3313 iw = convert_to_FL_Coord(w) 3314 ih = convert_to_FL_Coord(h) 3315 ulcolr = convert_to_FL_COLOR(colr) 3316 ibwIn = convert_to_int(bwIn) 3317 keep_elem_refs(style, istyle, x, ix, y, iy, w, iw, h, ih, colr, 3318 ulcolr, bwIn, ibwIn) 3319 _fl_drw_box(style, x, y, w, h, ulcolr, ibwIn)
3320 3321 3322 FL_DRAWPTR = cty.CFUNCTYPE(None, FL_Coord, FL_Coord, FL_Coord, FL_Coord, 3323 cty.c_int, FL_COLOR) 3324
3325 -def fl_add_symbol(name, py_DrawPtr, scalable):
3326 """ 3327 fl_add_symbol(name, py_DrawPtr, scalable) -> num. 3328 3329 Adds a symbol. 3330 3331 @param name : name of a symbol 3332 @param py_DrawPtr : python function to draw symbol, fn(coord, coord, 3333 coord, coord, num, colr) 3334 @param scalable : not used 3335 """ 3336 3337 _fl_add_symbol = cfuncproto( 3338 load_so_libforms(), "fl_add_symbol",\ 3339 cty.c_int, [STRING, FL_DRAWPTR, cty.c_int],\ 3340 """int fl_add_symbol(const char * name, FL_DRAWPTR drawit, 3341 int scalable) 3342 """) 3343 s_name = convert_to_string(name) 3344 iscalable = convert_to_int(scalable) 3345 c_DrawPtr = FL_DRAWPTR(py_DrawPtr) 3346 keep_cfunc_refs(c_DrawPtr, py_DrawPtr) 3347 keep_elem_refs(name, s_name, scalable, iscalable) 3348 retval = _fl_add_symbol(s_name, c_DrawPtr, iscalable) 3349 return retval
3350 3351
3352 -def fl_draw_symbol(label, x, y, w, h, colr):
3353 """ fl_draw_symbol(label, x, y, w, h, colr) -> num. 3354 """ 3355 3356 _fl_draw_symbol = cfuncproto( 3357 load_so_libforms(), "fl_draw_symbol",\ 3358 cty.c_int, [STRING, FL_Coord, FL_Coord, FL_Coord, FL_Coord, 3359 FL_COLOR],\ 3360 """int fl_draw_symbol(const char * label, FL_Coord x, FL_Coord y, 3361 FL_Coord w, FL_Coord h, FL_COLOR col) 3362 """) 3363 slabel = convert_to_string(label) 3364 ix = convert_to_FL_Coord(x) 3365 iy = convert_to_FL_Coord(y) 3366 iw = convert_to_FL_Coord(w) 3367 ih = convert_to_FL_Coord(h) 3368 ulcolr = convert_to_FL_COLOR(colr) 3369 keep_elem_refs(label, slabel, x, ix, y, iy, w, iw, h, ih, colr, 3370 ulcolr) 3371 retval = _fl_draw_symbol(slabel, ix, iy, iw, ih, ulcolr) 3372 return retval
3373 3374
3375 -def fl_mapcolor(colr, r, g, b):
3376 """ fl_mapcolor(colr, r, g, b) -> num. 3377 """ 3378 3379 _fl_mapcolor = cfuncproto( 3380 load_so_libforms(), "fl_mapcolor",\ 3381 cty.c_ulong, [FL_COLOR, cty.c_int, cty.c_int, cty.c_int],\ 3382 """long unsigned int fl_mapcolor(FL_COLOR col, int r, int g, int b) 3383 """) 3384 ulcolr = convert_to_FL_COLOR(colr) 3385 ir = convert_to_int(r) 3386 ig = convert_to_int(g) 3387 ib = convert_to_int(b) 3388 keep_elem_refs(colr, ulcolr, r, ir, g, ig, b, ib) 3389 retval = _fl_mapcolor(ulcolr, ir, ig, ib) 3390 return retval
3391 3392
3393 -def fl_mapcolorname(colr, name):
3394 """ fl_mapcolorname(colr, name) -> num. 3395 """ 3396 3397 _fl_mapcolorname = cfuncproto( 3398 load_so_libforms(), "fl_mapcolorname",\ 3399 cty.c_long, [FL_COLOR, STRING],\ 3400 """long int fl_mapcolorname(FL_COLOR col, const char * name) 3401 """) 3402 ulcolr = convert_to_FL_COLOR(colr) 3403 sname = convert_to_string(name) 3404 keep_elem_refs(colr, ulcolr, name, sname) 3405 retval = _fl_mapcolorname(ulcolr, sname) 3406 return retval
3407 3408 3409 fl_mapcolor_name = fl_mapcolorname 3410 3411
3412 -def fl_free_colors(c, n):
3413 """ fl_free_colors(c, n) 3414 """ 3415 3416 _fl_free_colors = cfuncproto( 3417 load_so_libforms(), "fl_free_colors",\ 3418 None, [cty.POINTER(FL_COLOR), cty.c_int],\ 3419 """void fl_free_colors(FL_COLOR * c, int n) 3420 """) 3421 inum = convert_to_int(n) 3422 keep_elem_refs(c, n, inum) 3423 _fl_free_colors(c, inum)
3424 3425
3426 -def fl_free_pixels(pix, n):
3427 """ fl_free_pixels(pix, n) 3428 """ 3429 3430 _fl_free_pixels = cfuncproto( 3431 load_so_libforms(), "fl_free_pixels",\ 3432 None, [cty.POINTER(cty.c_ulong), cty.c_int],\ 3433 """void fl_free_pixels(long unsigned int * pix, int n) 3434 """) 3435 inum = convert_to_int(n) 3436 keep_elem_refs(pix, n, inum) 3437 _fl_free_pixels(pix, inum)
3438 3439
3440 -def fl_set_color_leak(y):
3441 """ fl_set_color_leak(y) 3442 """ 3443 3444 _fl_set_color_leak = cfuncproto( 3445 load_so_libforms(), "fl_set_color_leak",\ 3446 None, [cty.c_int],\ 3447 """void fl_set_color_leak(int y) 3448 """) 3449 iy = convert_to_int(y) 3450 keep_elem_refs(y, iy) 3451 _fl_set_color_leak(iy)
3452 3453 3454 #def fl_getmcolor(colr, r, g, b) *API change*
3455 -def fl_getmcolor(colr):
3456 """ fl_getmcolor(colr) -> num., r, g,b 3457 """ 3458 3459 _fl_getmcolor = cfuncproto( 3460 load_so_libforms(), "fl_getmcolor",\ 3461 cty.c_ulong, [FL_COLOR, cty.POINTER(cty.c_int),\ 3462 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)],\ 3463 """long unsigned int fl_getmcolor(FL_COLOR i, int * r, int * g, 3464 int * b) 3465 """) 3466 check_admitted_listvalues(colr, COLOR_list) 3467 ulcolr = convert_to_FL_COLOR(colr) 3468 r, pr = make_int_and_pointer() 3469 g, pg = make_int_and_pointer() 3470 b, pb = make_int_and_pointer() 3471 keep_elem_refs(colr, ulcolr, r, g, b, pr, pg, pb) 3472 retval = _fl_getmcolor(ulcolr, pr, pg, pb) 3473 return retval, r, g,b
3474 3475
3476 -def fl_get_pixel(colr):
3477 """ fl_get_pixel(colr) -> pixel num. 3478 """ 3479 3480 _fl_get_pixel = cfuncproto( 3481 load_so_libforms(), "fl_get_pixel",\ 3482 cty.c_ulong, [FL_COLOR],\ 3483 """long unsigned int fl_get_pixel(FL_COLOR col) 3484 """) 3485 check_admitted_listvalues(colr, COLOR_list) 3486 ulcolr = convert_to_FL_COLOR(colr) 3487 keep_elem_refs(colr, ulcolr) 3488 retval = _fl_get_pixel(ulcolr) 3489 return retval
3490 3491 3492 fl_get_flcolor = fl_get_pixel 3493 3494 3495 #def fl_get_icm_color(colr, r, g, b) *API change*
3496 -def fl_get_icm_color(colr):
3497 """ fl_get_icm_color(colr) -> r, g,b 3498 """ 3499 3500 _fl_get_icm_color = cfuncproto( 3501 load_so_libforms(), "fl_get_icm_color",\ 3502 None, [FL_COLOR, cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 3503 cty.POINTER(cty.c_int)],\ 3504 """void fl_get_icm_color(FL_COLOR col, int * r, int * g, int * b) 3505 """) 3506 check_admitted_listvalues(colr, COLOR_list) 3507 ulcolr = convert_to_FL_COLOR(colr) 3508 r, pr = make_int_and_pointer() 3509 g, pg = make_int_and_pointer() 3510 b, pb = make_int_and_pointer() 3511 keep_elem_refs(colr, ulcolr, r, g, b, pr, pg, pb) 3512 _fl_get_icm_color(ulcolr, pr, pg, pb) 3513 return r, g,b
3514 3515
3516 -def fl_set_icm_color(colr, r, g, b):
3517 """ fl_set_icm_color(colr, r, g, b) 3518 """ 3519 3520 _fl_set_icm_color = cfuncproto( 3521 load_so_libforms(), "fl_set_icm_color",\ 3522 None, [FL_COLOR, cty.c_int, cty.c_int, cty.c_int],\ 3523 """void fl_set_icm_color(FL_COLOR col, int r, int g, int b) 3524 """) 3525 ulcolr = convert_to_FL_COLOR(colr) 3526 ir = convert_to_int(r) 3527 ig = convert_to_int(g) 3528 ib = convert_to_int(b) 3529 keep_elem_refs(colr, ulcolr, r, g, b, ir, ig, ib) 3530 _fl_set_icm_color(ulcolr, ir, ig, ib)
3531 3532
3533 -def fl_color(colr):
3534 """ fl_color(colr) 3535 """ 3536 3537 _fl_color = cfuncproto( 3538 load_so_libforms(), "fl_color",\ 3539 None, [FL_COLOR],\ 3540 """void fl_color(FL_COLOR col) 3541 """) 3542 check_admitted_listvalues(colr, COLOR_list) 3543 ulcolr = convert_to_FL_COLOR(colr) 3544 keep_elem_refs(colr, ulcolr) 3545 _fl_color(ulcolr)
3546 3547
3548 -def fl_bk_color(colr):
3549 """ fl_bk_color(colr) 3550 """ 3551 3552 _fl_bk_color = cfuncproto( 3553 load_so_libforms(), "fl_bk_color",\ 3554 None, [FL_COLOR],\ 3555 """void fl_bk_color(FL_COLOR col) 3556 """) 3557 check_admitted_listvalues(colr, COLOR_list) 3558 ulcolr = convert_to_FL_COLOR(colr) 3559 keep_elem_refs(colr, ulcolr) 3560 _fl_bk_color(ulcolr)
3561 3562
3563 -def fl_textcolor(colr):
3564 """ fl_textcolor(colr) 3565 """ 3566 3567 _fl_textcolor = cfuncproto( 3568 load_so_libforms(), "fl_textcolor",\ 3569 None, [FL_COLOR],\ 3570 """void fl_textcolor(FL_COLOR col) 3571 """) 3572 check_admitted_listvalues(colr, COLOR_list) 3573 ulcolr = convert_to_FL_COLOR(colr) 3574 keep_elem_refs(colr, ulcolr) 3575 _fl_textcolor(ulcolr)
3576 3577
3578 -def fl_bk_textcolor(colr):
3579 """ fl_bk_textcolor(colr) 3580 """ 3581 3582 _fl_bk_textcolor = cfuncproto( 3583 load_so_libforms(), "fl_bk_textcolor",\ 3584 None, [FL_COLOR],\ 3585 """void fl_bk_textcolor(FL_COLOR col) 3586 """) 3587 check_admitted_listvalues(colr, COLOR_list) 3588 ulcolr = convert_to_FL_COLOR(colr) 3589 keep_elem_refs(colr, ulcolr) 3590 _fl_bk_textcolor(ulcolr)
3591 3592
3593 -def fl_set_gamma(r, g, b):
3594 """ 3595 fl_set_gamma(r, g, b) 3596 3597 @param r : value for red 3598 @param g : value for green 3599 @param b : value for blue 3600 """ 3601 3602 _fl_set_gamma = cfuncproto( 3603 load_so_libforms(), "fl_set_gamma",\ 3604 None, [cty.c_double, cty.c_double, cty.c_double],\ 3605 """void fl_set_gamma(double r, double g, double b) 3606 """) 3607 fr = convert_to_double(r) 3608 fg = convert_to_double(g) 3609 fb = convert_to_double(b) 3610 keep_elem_refs(r, fr, g, fg, b, fb) 3611 _fl_set_gamma(fr, fg, fb)
3612 3613
3614 -def fl_show_errors(y):
3615 """ fl_show_errors(y) 3616 """ 3617 3618 _fl_show_errors = cfuncproto( 3619 load_so_libforms(), "fl_show_errors",\ 3620 None, [cty.c_int],\ 3621 """void fl_show_errors(int y) 3622 """) 3623 iy = convert_to_int(y) 3624 keep_elem_refs(y, iy) 3625 _fl_show_errors(iy)
3626 3627 3628 # Some macros 3629
3630 -def FL_max(a, b):
3631 if (a > b): 3632 return a 3633 else: 3634 return b
3635
3636 -def FL_min(a, b):
3637 if (a < b): 3638 return a 3639 else: 3640 return b
3641
3642 -def FL_abs(a):
3643 if (a > 0): 3644 return a 3645 else: 3646 return (-a)
3647
3648 -def FL_nint(a):
3649 if int(a) > 0: 3650 return (a + 0.5) 3651 else: 3652 return (a - 0.5)
3653
3654 -def FL_clamp(a, amin, amax):
3655 if (a < amin): 3656 return amin 3657 elif (a > amax): 3658 return amax 3659 else: 3660 return a
3661
3662 -def FL_crnd(a):
3663 if FL_Coord(a) > 0: 3664 return (a + 0.5) 3665 else: 3666 return (a - 0.5)
3667 3668 3669 # utilities for new objects 3670
3671 -def fl_add_object(pForm, pObject):
3672 """ 3673 fl_add_object(pForm, pObject) 3674 3675 @param pForm : pointer to form 3676 @param pObject : pointer to object 3677 """ 3678 3679 _fl_add_object = cfuncproto( 3680 load_so_libforms(), "fl_add_object",\ 3681 None, [cty.POINTER(FL_FORM), cty.POINTER(FL_OBJECT)],\ 3682 """void fl_add_object(FL_FORM * form, FL_OBJECT * obj) 3683 """) 3684 keep_elem_refs(pForm, pObject) 3685 _fl_add_object(pForm, pObject)
3686 3687
3688 -def fl_addto_form(pForm):
3689 """ 3690 fl_addto_form(pForm) -> pForm 3691 3692 Reopens a form for input. 3693 3694 @param pForm : pointer to form 3695 """ 3696 3697 _fl_addto_form = cfuncproto( 3698 load_so_libforms(), "fl_addto_form", 3699 cty.POINTER(FL_FORM), [cty.POINTER(FL_FORM)],\ 3700 """FL_FORM * fl_addto_form(FL_FORM * form) 3701 """) 3702 keep_elem_refs(pForm) 3703 retval = _fl_addto_form(pForm) 3704 return retval
3705 3706
3707 -def fl_make_object(objclass, objtype, x, y, w, h, label, py_HandlePtr):
3708 """ 3709 fl_make_object(objclass, objtype, x, y, w, h, label, py_HandlePtr) -> pObject 3710 """ 3711 3712 _fl_make_object = cfuncproto( 3713 load_so_libforms(), "fl_make_object",\ 3714 cty.POINTER(FL_OBJECT), [cty.c_int, cty.c_int, FL_Coord,\ 3715 FL_Coord, FL_Coord, FL_Coord, STRING, FL_HANDLEPTR],\ 3716 """FL_OBJECT * fl_make_object(int objclass, int type, FL_Coord x, 3717 FL_Coord y, FL_Coord w, FL_Coord h, const char * label, 3718 FL_HANDLEPTR handle) 3719 """) 3720 iobjclass = convert_to_int(objclass) 3721 iobjtype = convert_to_int(objtype) 3722 ix = convert_to_FL_Coord(x) 3723 iy = convert_to_FL_Coord(y) 3724 iw = convert_to_FL_Coord(w) 3725 ih = convert_to_FL_Coord(h) 3726 slabel = convert_to_string(label) 3727 c_HandlePtr = FL_HANDLEPTR(py_HandlePtr) 3728 keep_cfunc_refs(c_HandlePtr, py_HandlePtr) 3729 keep_elem_refs(objclass, objtype, x, y, w, h, label, iobjclass, 3730 iobjtype, ix, iy, iw, ih, slabel) 3731 retval = _fl_make_object(iobjclass, iobjtype, ix, iy, iw, 3732 ih, slabel, c_HandlePtr) 3733 return retval
3734 3735
3736 -def fl_add_child(pObject1, pObject2):
3737 """ 3738 fl_add_child(pObject1, pObject2) 3739 3740 @param pObject1 : pointer to father object 3741 @param pObject2 : pointer to child object 3742 """ 3743 3744 _fl_add_child = cfuncproto( 3745 load_so_libforms(), "fl_add_child",\ 3746 None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_OBJECT)],\ 3747 """void fl_add_child(FL_OBJECT * p1, FL_OBJECT * p2) 3748 """) 3749 keep_elem_refs(pObject1, pObject2) 3750 _fl_add_child(pObject1, pObject2)
3751 3752
3753 -def fl_set_coordunit(u):
3754 """ 3755 fl_set_coordunit(u) 3756 3757 @param u :? 3758 """ 3759 3760 _fl_set_coordunit = cfuncproto( 3761 load_so_libforms(), "fl_set_coordunit",\ 3762 None, [cty.c_int],\ 3763 """void fl_set_coordunit(int u) 3764 """) 3765 iu = convert_to_int(u) 3766 keep_elem_refs(u, iu) 3767 _fl_set_coordunit(iu)
3768 3769
3770 -def fl_set_border_width(bw):
3771 """ 3772 fl_set_border_width(bw) 3773 3774 Sets the width of the border. 3775 3776 @param bw : width of border 3777 """ 3778 3779 _fl_set_border_width = cfuncproto( 3780 load_so_libforms(), "fl_set_border_width",\ 3781 None, [cty.c_int],\ 3782 """void fl_set_border_width(int bw) 3783 """) 3784 ibw = convert_to_int(bw) 3785 keep_elem_refs(bw, ibw) 3786 _fl_set_border_width(ibw)
3787 3788
3789 -def fl_set_scrollbar_type(sbtype):
3790 """ 3791 fl_set_scrollbar_type(sbtype) 3792 3793 @param sbtype : type of scrollbar 3794 """ 3795 3796 _fl_set_scrollbar_type = cfuncproto( 3797 load_so_libforms(), "fl_set_scrollbar_type",\ 3798 None, [cty.c_int],\ 3799 """void fl_set_scrollbar_type(int t) 3800 """) 3801 check_admitted_listvalues(sbtype, SCROLLTYPE_list) 3802 isbtype = convert_to_int(sbtype) 3803 keep_elem_refs(sbtype, isbtype) 3804 _fl_set_scrollbar_type(isbtype)
3805 3806
3807 -def fl_set_thinscrollbar(t):
3808 if t: 3809 t_type = FL_THIN_SCROLLBAR 3810 else: 3811 t_type = FL_NORMAL_SCROLLBAR 3812 fl_set_scrollbar_type(t_type)
3813 3814
3815 -def fl_flip_yorigin():
3816 """ fl_flip_yorigin() 3817 """ 3818 3819 _fl_flip_yorigin = cfuncproto( 3820 load_so_libforms(), "fl_flip_yorigin",\ 3821 None, [],\ 3822 """void fl_flip_yorigin() 3823 """) 3824 _fl_flip_yorigin()
3825 3826
3827 -def fl_get_coordunit():
3828 """ fl_get_coordunit() -> coord_unit num. 3829 """ 3830 3831 _fl_get_coordunit = cfuncproto( 3832 load_so_libforms(), "fl_get_coordunit",\ 3833 cty.c_int, [],\ 3834 """int fl_get_coordunit() 3835 """) 3836 retval = _fl_get_coordunit() 3837 return retval
3838 3839
3840 -def fl_get_border_width():
3841 """ fl_get_border_width() -> width num. 3842 """ 3843 3844 _fl_get_border_width = cfuncproto( 3845 load_so_libforms(), "fl_get_border_width",\ 3846 cty.c_int, [],\ 3847 """int fl_get_border_width() 3848 """) 3849 retval = _fl_get_border_width() 3850 return retval
3851 3852 3853 # misc. routines 3854
3855 -def fl_ringbell(percent):
3856 """ 3857 fl_ringbell(percent) 3858 3859 Sounds the keyboard ringbell (if capable). 3860 3861 @param percent : volume value for the bell, min -100 (off), max 100, 3862 0 is default 3863 """ 3864 3865 _fl_ringbell = cfuncproto( 3866 load_so_libforms(), "fl_ringbell",\ 3867 None, [cty.c_int],\ 3868 """void fl_ringbell(int percent) 3869 """) 3870 ipercent = convert_to_int(percent) 3871 keep_elem_refs(percent, ipercent) 3872 _fl_ringbell(ipercent)
3873 3874 3875 #def fl_gettime(sec, usec) *API change*
3876 -def fl_gettime():
3877 """ 3878 fl_gettime() -> sec, usec 3879 3880 Returns the current time, expressed in seconds and microseconds 3881 since 00:00 GMT January, 1970. It is most useful for computing 3882 time differences 3883 """ 3884 3885 _fl_gettime = cfuncproto( 3886 load_so_libforms(), "fl_gettime",\ 3887 None, [cty.POINTER(cty.c_long), cty.POINTER(cty.c_long)],\ 3888 """void fl_gettime(long int * sec, long int * usec) 3889 """) 3890 sec, psec = make_long_and_pointer() 3891 usec, pusec = make_long_and_pointer() 3892 keep_elem_refs(sec, usec, psec, pusec) 3893 _fl_gettime(psec, pusec) 3894 return sec, usec
3895 3896
3897 -def fl_now():
3898 """ 3899 fl_now() -> string 3900 3901 Returns a string form of the current date and time. The format of 3902 the string is of the form "Wed Jun 30 21:49:08 1993" 3903 """ 3904 3905 _fl_now = cfuncproto( 3906 load_so_libforms(), "fl_now",\ 3907 STRING, [],\ 3908 """const char * fl_now() 3909 """) 3910 retval = _fl_now() 3911 return retval
3912 3913
3914 -def fl_whoami():
3915 """ 3916 fl_whoami() -> string 3917 3918 Returns the user name who is running the application. 3919 """ 3920 3921 _fl_whoami = cfuncproto( 3922 load_so_libforms(), "fl_whoami",\ 3923 STRING, [],\ 3924 """const char * fl_whoami() 3925 """) 3926 retval = _fl_whoami() 3927 return retval
3928 3929
3930 -def fl_mouse_button():
3931 """ fl_mouse_button() -> num. 3932 """ 3933 3934 _fl_mouse_button = cfuncproto( 3935 load_so_libforms(), "fl_mouse_button",\ 3936 cty.c_long, [],\ 3937 """long int fl_mouse_button() 3938 """) 3939 retval = _fl_mouse_button() 3940 return retval
3941 3942 fl_mousebutton = fl_mouse_button 3943 3944 3945
3946 -def fl_strdup(strng):
3947 """ fl_strdup(strng) -> string 3948 """ 3949 3950 _fl_strdup = cfuncproto( 3951 load_so_libforms(), "fl_strdup",\ 3952 STRING, [STRING],\ 3953 """char * fl_strdup(const char * s) 3954 """) 3955 sstrng = convert_to_string(strng) 3956 keep_elem_refs(strng, sstrng) 3957 retval = _fl_strdup(sstrng) 3958 return retval
3959 3960
3961 -def fl_set_err_logfp(pFile):
3962 """ fl_set_err_logfp(pFile) 3963 """ 3964 3965 _fl_set_err_logfp = cfuncproto( 3966 load_so_libforms(), "fl_set_err_logfp",\ 3967 None, [cty.POINTER(FILE)],\ 3968 """void fl_set_err_logfp(FILE * fp) 3969 """) 3970 keep_elem_refs(pFile) 3971 _fl_set_err_logfp(pFile)
3972 3973 # This function was called 'fl_set_error_logfp/' in XForms 0.89. 3974 fl_set_error_logfp = fl_set_err_logfp 3975 3976 3977
3978 -def fl_set_error_handler(py_ErrorFunc):
3979 """ 3980 fl_set_error_handler(py_ErrorFunc) 3981 """ 3982 3983 _fl_set_error_handler = cfuncproto( 3984 load_so_libforms(), "fl_set_error_handler",\ 3985 None, [FL_ERROR_FUNC],\ 3986 """void fl_set_error_handler(FL_ERROR_FUNC user_func) 3987 """) 3988 c_ErrorFunc = FL_ERROR_FUNC(py_ErrorFunc) 3989 keep_cfunc_refs(c_ErrorFunc, py_ErrorFunc) 3990 retval = _fl_set_error_handler(c_ErrorFunc) 3991 return retval
3992 3993
3994 -def fl_get_cmdline_args(p1):
3995 """ fl_get_cmdline_args(p1) -> string 3996 """ 3997 3998 _fl_get_cmdline_args = cfuncproto( 3999 load_so_libforms(), "fl_get_cmdline_args",\ 4000 cty.POINTER(STRING), [cty.POINTER(cty.c_int)],\ 4001 """)char * * fl_get_cmdline_args(int * p1) 4002 """) 4003 keep_elem_refs(p1) 4004 retval = _fl_get_cmdline_args(p1) 4005 return retval
4006 4007 4008 # these give more flexibility for future changes. Also application 4009 # can re-assign these pointers to whatever function it wants, e.g., 4010 # to a shared memory pool allocator. 4011 4012 #fl_free = (cty.CFUNCTYPE(None, cty.c_void_p)).in_dll(load_so_libforms(), 'fl_free')
4013 -def fl_free(p1):
4014 """ fl_free(p1) 4015 """ 4016 4017 _fl_free = cfuncproto( 4018 load_so_libforms(), "fl_free",\ 4019 None, [cty.c_void_p], 4020 """void ( * fl_free )( void *) 4021 """) 4022 keep_elem_refs(p1) 4023 _fl_free(p1)
4024 4025 4026 # cfunction for _fl_malloc 4027 cfunc_none_sizet = cty.CFUNCTYPE(cty.c_void_p, size_t) 4028 4029 # low-level function maybe unused in python 4030 ##fl_malloc = (cty.CFUNCTYPE(cty.c_void_p, size_t)).in_dll(load_so_libforms(), 4031 # 'fl_malloc') 4032 #def fl_malloc(size): 4033 # """ fl_malloc(size) -> pointer 4034 # """# 4035 # _fl_malloc = cfuncproto( 4036 # load_so_libforms(), "fl_malloc",\ 4037 # cty.c_void_p, [size_t], 4038 # """void * ( * fl_malloc )( size_t) 4039 # """) 4040 # uisize = convert_to_uint(size) 4041 # keep_elem_refs(size, uisize) 4042 # retval = _fl_malloc(uisize) 4043 # return retval 4044 4045 4046 # cfunction for _fl_calloc 4047 cfunc_none_sizet_sizet = cty.CFUNCTYPE(cty.c_void_p, size_t, size_t) 4048 4049 # low-level function maybe unused in python 4050 ##fl_calloc = (cty.CFUNCTYPE(cty.c_void_p, size_t, size_t)).in_dll(\ 4051 # load_so_libforms(), 'fl_calloc') 4052 #def fl_calloc(size): 4053 # """ fl_calloc(size) -> pointer 4054 # """# 4055 # _fl_calloc = cfuncproto( 4056 # load_so_libforms(), "fl_malloc",\ 4057 # cty.c_void_p, [size_t, size_t], 4058 # """void * ( * fl_calloc )( size_t) 4059 # """) 4060 # uisize = convert_to_uint(size) 4061 # keep_elem_refs(size, uisize) 4062 # retval = _fl_calloc(uisize) 4063 # return retval 4064 4065 4066 # cfunction for _fl_realloc 4067 cfunc_voidp_voidp_sizet = cty.CFUNCTYPE(cty.c_void_p, cty.c_void_p, size_t) 4068 4069 # low-level function maybe unused in python 4070 ##fl_realloc = (cty.CFUNCTYPE(cty.c_void_p, cty.c_void_p, size_t)).in_dll(\ 4071 # load_so_libforms(), 'fl_realloc') 4072 #def fl_realloc(py_p1, size): 4073 # """ fl_realloc(py_p1, size) -> pointer 4074 # """# 4075 # _fl_realloc = cfuncproto( 4076 # load_so_libforms(), "fl_realloc",\ 4077 # cty.c_void_p, [cty.c_void_p, size_t], 4078 # """void * ( * fl_realloc )( void* 4079 # """) 4080 # uisize = convert_to_uint(size) 4081 # c_p1 = cfunc_voidp_voidp_sizet(py_p1) 4082 # keep_cfunc_refs(c_p1) 4083 # keep_elem_refs(size, uisize) 4084 # retval = _fl_realloc(c_p1, uisize) 4085 # return retval 4086 4087
4088 -def fl_msleep(msec):
4089 """ 4090 fl_msleep(msec) -> num. 4091 4092 Waits for a number of milliseconds (with the best resolution 4093 possible on your system) 4094 4095 @param msec : milliseconds to sleep 4096 """ 4097 4098 _fl_msleep = cfuncproto( 4099 load_so_libforms(), "fl_msleep",\ 4100 cty.c_int, [cty.c_ulong],\ 4101 """int fl_msleep(long unsigned int msec) 4102 """) 4103 ulmsec = convert_to_ulong(msec) 4104 keep_elem_refs(msec, ulmsec) 4105 retval = _fl_msleep(ulmsec) 4106 return retval
4107 4108
4109 -def fl_is_same_object(pObject1, pObject2):
4110 """ 4111 fl_is_same_object(pObject1, pObject2) -> num. 4112 4113 Does a comparison between two objects. 4114 """ 4115 4116 _fl_is_same_object = cfuncproto( 4117 load_so_libforms(), "fl_is_same_object", \ 4118 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_OBJECT)], \ 4119 """int fl_is_same_object(FL_OBJECT * obj1, FL_OBJECT * obj2) 4120 """) 4121 keep_elem_refs(pObject1, pObject2) 4122 retval = _fl_is_same_object(pObject1, pObject2) 4123 return retval
4124 4125 4126 4127 ################### 4128 # XBasic.h 4129 ################## 4130
4131 -def FL_is_gray(v):
4132 if (v == GrayScale) or (v == StaticGray): 4133 return True 4134 else: 4135 return False
4136 4137
4138 -def FL_is_rgb(v):
4139 if (v == TrueColor) or (v == DirectColor): 4140 return True 4141 else: 4142 return False
4143 4144 4145 # Current version only runs in single visual mode
4146 -def fl_get_vclass():
4147 return fl_vmode
4148 4149
4150 -def fl_get_form_vclass(a):
4151 return fl_vmode
4152 4153
4154 -def fl_get_gc():
4155 return fl_state[fl_vmode].gc[0]
4156 4157
4158 -def fl_mode_capable(mode, warn):
4159 """ 4160 fl_mode_capable(mode, warn) -> mode num. 4161 4162 Determines the visual classes the system is capable of. It returns 4163 1 if the system is capable of displaying in this visual class and 4164 0 otherwise. 4165 4166 @param mode : visual mode (i.e. xfc.FL_GrayScale, xfc.FL_StaticGray, 4167 xfc.FL_PseudoColor, xfc.FL_StaticColor, xfc.FL_DirectColor and 4168 xfc.FL_TrueColor) 4169 @param warn : warning (0|1), if set a warning is printed out in case 4170 the capability asked for isn't available 4171 """ 4172 4173 _fl_mode_capable = cfuncproto( 4174 load_so_libforms(), "fl_mode_capable",\ 4175 cty.c_int, [cty.c_int, cty.c_int],\ 4176 """int fl_mode_capable(int mode, int warn) 4177 """) 4178 imode = convert_to_int(mode) 4179 iwarn = convert_to_int(warn) 4180 keep_elem_refs(mode, warn, imode, iwarn) 4181 retval = _fl_mode_capable(imode, iwarn) 4182 return retval
4183 4184
4185 -def fl_default_win():
4186 return fl_state[fl_vmode].trailblazer
4187 4188
4189 -def fl_default_window():
4190 return fl_state[fl_vmode].trailblazer
4191 4192 4193 # Some basic drawing routines 4194 4195 # Rectangles 4196
4197 -def fl_rectangle(fill, x, y, w, h, colr):
4198 """ fl_rectangle(fill, x, y, w, h, colr) 4199 """ 4200 4201 _fl_rectangle = cfuncproto( 4202 load_so_libforms(), "fl_rectangle",\ 4203 None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, 4204 FL_COLOR],\ 4205 """void fl_rectangle(int fill, FL_Coord x, FL_Coord y, 4206 FL_Coord w, FL_Coord h, FL_COLOR col) 4207 """) 4208 check_admitted_listvalues(colr, COLOR_list) 4209 ifill = convert_to_int(fill) 4210 ix = convert_to_FL_Coord(x) 4211 iy = convert_to_FL_Coord(y) 4212 iw = convert_to_FL_Coord(w) 4213 ih = convert_to_FL_Coord(h) 4214 ulcolr = convert_to_FL_COLOR(colr) 4215 keep_elem_refs(fill, x, y, w, h, colr, ifill, ix, iy, iw, ih, 4216 ulcolr) 4217 _fl_rectangle(ifill, ix, iy, iw, ih, ulcolr)
4218 4219
4220 -def fl_rectbound(x, y, w, h, colr):
4221 """ fl_rectbound(x, y, w, h, colr) 4222 """ 4223 4224 _fl_rectbound = cfuncproto( 4225 load_so_libforms(), "fl_rectbound",\ 4226 None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord, FL_COLOR],\ 4227 """void fl_rectbound(FL_Coord x, FL_Coord y, FL_Coord w, 4228 FL_Coord h, FL_COLOR col) 4229 """) 4230 check_admitted_listvalues(colr, COLOR_list) 4231 ix = convert_to_FL_Coord(x) 4232 iy = convert_to_FL_Coord(y) 4233 iw = convert_to_FL_Coord(w) 4234 ih = convert_to_FL_Coord(h) 4235 ulcolr = convert_to_FL_COLOR(colr) 4236 keep_elem_refs(x, y, w, h, colr, ix, iy, iw, ih, ulcolr) 4237 _fl_rectbound(ix, iy, iw, ih, ulcolr)
4238 4239
4240 -def fl_rectf(x, y, w, h, colr):
4241 fl_rectangle(1, x, y, w, h, colr)
4242 4243
4244 -def fl_rect(x, y, w, h, colr):
4245 fl_rectangle(0, x, y, w, h, colr)
4246 4247 4248 # Rectangle with rounded-corners 4249
4250 -def fl_roundrectangle(fill, x, y, w, h, colr):
4251 """ fl_roundrectangle(fill, x, y, w, h, colr) 4252 """ 4253 4254 _fl_roundrectangle = cfuncproto( 4255 load_so_libforms(), "fl_roundrectangle",\ 4256 None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, 4257 FL_COLOR],\ 4258 """void fl_roundrectangle(int fill, FL_Coord x, FL_Coord y, 4259 FL_Coord w, FL_Coord h, FL_COLOR col) 4260 """) 4261 check_admitted_listvalues(colr, COLOR_list) 4262 ifill = convert_to_int(fill) 4263 ix = convert_to_FL_Coord(x) 4264 iy = convert_to_FL_Coord(y) 4265 iw = convert_to_FL_Coord(w) 4266 ih = convert_to_FL_Coord(h) 4267 ulcolr = convert_to_FL_COLOR(colr) 4268 keep_elem_refs(fill, x, y, w, h, colr, ifill, ix, iy, iw, ih, 4269 ulcolr) 4270 _fl_roundrectangle(ifill, ix, iy, iw, ih, ulcolr)
4271 4272
4273 -def fl_roundrectf(x, y, w, h, colr):
4274 fl_roundrectangle(1, x, y, w, h, colr)
4275 4276
4277 -def fl_roundrect(x, y, w, h, colr):
4278 fl_roundrectangle(0, x, y, w, h, colr)
4279 4280 4281 # General polygon and polylines 4282
4283 -def fl_polygon(fill, pPoint, n, colr):
4284 """ fl_polygon(fill, pPoint, n, colr) 4285 """ 4286 4287 _fl_polygon = cfuncproto( 4288 load_so_libforms(), "fl_polygon",\ 4289 None, [cty.c_int, cty.POINTER(FL_POINT), cty.c_int, FL_COLOR],\ 4290 """void fl_polygon(int fill, FL_POINT * xp, int n, FL_COLOR col) 4291 """) 4292 check_admitted_listvalues(colr, COLOR_list) 4293 ifill = convert_to_int(fill) 4294 inum = convert_to_int(n) 4295 ulcolr = convert_to_FL_COLOR(colr) 4296 keep_elem_refs(fill, pPoint, n, colr, ifill, inum, ulcolr) 4297 _fl_polygon(ifill, pPoint, inum, ulcolr)
4298 4299
4300 -def fl_polyf(pPoint, n, colr):
4301 fl_polygon(1, pPoint, n, colr)
4302 4303
4304 -def fl_polyl(pPoint, n, colr):
4305 fl_polygon(0, pPoint, n, colr)
4306
4307 -def fl_polybound(pPoint, n, colr):
4308 fl_polygon(1, pPoint, n, colr) 4309 fl_polygon(0, pPoint, n, FL_BLACK)
4310 4311
4312 -def fl_lines(pPoint, n, colr):
4313 """ fl_lines(pPoint, n, colr) 4314 """ 4315 4316 _fl_lines = cfuncproto( 4317 load_so_libforms(), "fl_lines",\ 4318 None, [cty.POINTER(FL_POINT), cty.c_int, FL_COLOR],\ 4319 """void fl_lines(FL_POINT * xp, int n, FL_COLOR col) 4320 """) 4321 check_admitted_listvalues(colr, COLOR_list) 4322 inum = convert_to_int(n) 4323 ulcolr = convert_to_FL_COLOR(colr) 4324 keep_elem_refs(pPoint, n, colr, inum, ulcolr) 4325 _fl_lines(pPoint, inum, ulcolr)
4326 4327
4328 -def fl_line(xi, yi, xf, yf, colr):
4329 """ fl_line(xi, yi, xf, yf, colr) 4330 """ 4331 4332 _fl_line = cfuncproto( 4333 load_so_libforms(), "fl_line",\ 4334 None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord, FL_COLOR],\ 4335 """void fl_line(FL_Coord xi, FL_Coord yi, FL_Coord xf, 4336 FL_Coord yf, FL_COLOR c) 4337 """) 4338 check_admitted_listvalues(colr, COLOR_list) 4339 ixi = convert_to_int(xi) 4340 iyi = convert_to_int(yi) 4341 ixf = convert_to_int(xf) 4342 iyf = convert_to_int(yf) 4343 ulcolr = convert_to_FL_COLOR(colr) 4344 keep_elem_refs(xi, yi, xf, yf, colr, ixi, iyi, ixf, iyf, ulcolr) 4345 _fl_line(ixi, iyi, ixf, iyf, ulcolr)
4346 4347
4348 -def fl_point(x, y, colr):
4349 """ fl_point(x, y, colr) 4350 """ 4351 4352 _fl_point = cfuncproto( 4353 load_so_libforms(), "fl_point",\ 4354 None, [FL_Coord, FL_Coord, FL_COLOR],\ 4355 """void fl_point(FL_Coord x, FL_Coord y, FL_COLOR c) 4356 """) 4357 check_admitted_listvalues(colr, COLOR_list) 4358 ix = convert_to_FL_Coord(x) 4359 iy = convert_to_FL_Coord(y) 4360 ulcolr = convert_to_FL_COLOR(colr) 4361 keep_elem_refs(x, y, colr, ix, iy, ulcolr) 4362 _fl_point(ix, iy, ulcolr)
4363 4364
4365 -def fl_points(pPoint, np, colr):
4366 """ fl_points(pPoint, np, colr) 4367 """ 4368 4369 _fl_points = cfuncproto( 4370 load_so_libforms(), "fl_points",\ 4371 None, [cty.POINTER(FL_POINT), cty.c_int, FL_COLOR],\ 4372 """void fl_points(FL_POINT * p, int np, FL_COLOR c) 4373 """) 4374 check_admitted_listvalues(colr, COLOR_list) 4375 inump = convert_to_int(np) 4376 ulcolr = convert_to_FL_COLOR(colr) 4377 keep_elem_refs(pPoint, np, colr, inump, ulcolr) 4378 _fl_points(pPoint, inump, ulcolr)
4379 4380 4381 fl_simple_line = fl_line 4382 4383
4384 -def fl_dashedlinestyle(dash, ndash):
4385 """ fl_dashedlinestyle(dash, ndash) 4386 """ 4387 4388 _fl_dashedlinestyle = cfuncproto( 4389 load_so_libforms(), "fl_dashedlinestyle",\ 4390 None, [STRING, cty.c_int],\ 4391 """void fl_dashedlinestyle(const char * dash, int ndash) 4392 """) 4393 sdash = convert_to_string(dash) 4394 indash = convert_to_int(ndash) 4395 keep_elem_refs(dash, ndash, sdash, indash) 4396 _fl_dashedlinestyle(sdash, indash)
4397 4398
4399 -def fl_update_display(block):
4400 """ fl_update_display(block) 4401 """ 4402 4403 _fl_update_display = cfuncproto( 4404 load_so_libforms(), "fl_update_display",\ 4405 None, [cty.c_int],\ 4406 """void fl_update_display(int block) 4407 """) 4408 iblock = convert_to_int(block) 4409 keep_elem_refs(block, iblock) 4410 _fl_update_display(iblock)
4411 4412
4413 -def fl_diagline(x, y, w, h, colr):
4414 fl_line(x, y, (x) + (w) - 1, (y) + (h) - 1, colr)
4415 4416 4417 # Line attributes 4418
4419 -def fl_linewidth(n):
4420 """ fl_linewidth(n) 4421 """ 4422 4423 _fl_linewidth = cfuncproto( 4424 load_so_libforms(), "fl_linewidth",\ 4425 None, [cty.c_int],\ 4426 """void fl_linewidth(int n) 4427 """) 4428 inum = convert_to_int(n) 4429 keep_elem_refs(n, inum) 4430 _fl_linewidth(inum)
4431 4432
4433 -def fl_linestyle(n):
4434 """ fl_linestyle(n) 4435 """ 4436 4437 _fl_linestyle = cfuncproto( 4438 load_so_libforms(), "fl_linestyle",\ 4439 None, [cty.c_int],\ 4440 """void fl_linestyle(int n) 4441 """) 4442 inum = convert_to_int(n) 4443 keep_elem_refs(n, inum) 4444 _fl_linestyle(inum)
4445 4446
4447 -def fl_drawmode(request):
4448 """ fl_drawmode(request) 4449 """ 4450 4451 _fl_drawmode = cfuncproto( 4452 load_so_libforms(), "fl_drawmode",\ 4453 None, [cty.c_int],\ 4454 """void fl_drawmode(int request) 4455 """) 4456 irequest = convert_to_int(request) 4457 keep_elem_refs(request, irequest) 4458 _fl_drawmode(irequest)
4459 4460
4461 -def fl_get_linewidth():
4462 """ fl_get_linewidth() -> width num. 4463 """ 4464 4465 _fl_get_linewidth = cfuncproto( 4466 load_so_libforms(), "fl_get_linewidth",\ 4467 cty.c_int, [],\ 4468 """int fl_get_linewidth() 4469 """) 4470 retval = _fl_get_linewidth() 4471 return retval
4472 4473
4474 -def fl_get_linestyle():
4475 """ fl_get_linestyle() -> style num. 4476 """ 4477 4478 _fl_get_linestyle = cfuncproto( 4479 load_so_libforms(), "fl_get_linestyle",\ 4480 cty.c_int, [],\ 4481 """int fl_get_linestyle() 4482 """) 4483 retval = _fl_get_linestyle() 4484 return retval
4485 4486
4487 -def fl_get_drawmode():
4488 """ fl_get_drawmode() -> mode num. 4489 """ 4490 4491 _fl_get_drawmode = cfuncproto( 4492 load_so_libforms(), "fl_get_drawmode",\ 4493 cty.c_int, [],\ 4494 """int fl_get_drawmode() 4495 """) 4496 retval = _fl_get_drawmode() 4497 return retval
4498 4499 4500 fl_set_linewidth = fl_linewidth 4501 fl_set_linestyle = fl_linestyle 4502 fl_set_drawmode = fl_drawmode 4503 4504 4505 # Ellipses 4506
4507 -def fl_oval(fill, x, y, w, h, colr):
4508 """ fl_oval(fill, x, y, w, h, colr) 4509 """ 4510 4511 _fl_oval = cfuncproto( 4512 load_so_libforms(), "fl_oval",\ 4513 None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, 4514 FL_COLOR],\ 4515 """void fl_oval(int fill, FL_Coord x, FL_Coord y, FL_Coord w, 4516 FL_Coord h, FL_COLOR col) 4517 """) 4518 check_admitted_listvalues(colr, COLOR_list) 4519 ifill = convert_to_int(fill) 4520 ix = convert_to_FL_Coord(x) 4521 iy = convert_to_FL_Coord(y) 4522 iw = convert_to_FL_Coord(w) 4523 ih = convert_to_FL_Coord(h) 4524 ulcolr = convert_to_FL_COLOR(colr) 4525 keep_elem_refs(fill, x, y, w, h, colr, ifill, ix, iy, iw, ih, 4526 ulcolr) 4527 _fl_oval(ifill, ix, iy, iw, ih, ulcolr)
4528 4529
4530 -def fl_ovalbound(x, y, w, h, colr):
4531 """ fl_ovalbound(x, y, w, h, colr) 4532 """ 4533 4534 _fl_ovalbound = cfuncproto( 4535 load_so_libforms(), "fl_ovalbound",\ 4536 None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord, FL_COLOR],\ 4537 """void fl_ovalbound(FL_Coord x, FL_Coord y, FL_Coord w, 4538 FL_Coord h, FL_COLOR col) 4539 """) 4540 check_admitted_listvalues(colr, COLOR_list) 4541 ix = convert_to_FL_Coord(x) 4542 iy = convert_to_FL_Coord(y) 4543 iw = convert_to_FL_Coord(w) 4544 ih = convert_to_FL_Coord(h) 4545 ulcolr = convert_to_FL_COLOR(colr) 4546 keep_elem_refs(x, y, w, h, colr, ix, iy, iw, ih, ulcolr) 4547 _fl_ovalbound(ix, iy, iw, ih, ulcolr)
4548 4549
4550 -def fl_ovalarc(fill, x, y, w, h, t0, dt, colr):
4551 """ fl_ovalarc(fill, x, y, w, h, t0, dt, colr) 4552 """ 4553 4554 _fl_ovalarc = cfuncproto( 4555 load_so_libforms(), "fl_ovalarc",\ 4556 None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord, 4557 cty.c_int, cty.c_int, FL_COLOR],\ 4558 """void fl_ovalarc(int fill, FL_Coord x, FL_Coord y, FL_Coord w, 4559 FL_Coord h, int t0, int dt, FL_COLOR col) 4560 """) 4561 check_admitted_listvalues(colr, COLOR_list) 4562 ifill = convert_to_int(fill) 4563 ix = convert_to_FL_Coord(x) 4564 iy = convert_to_FL_Coord(y) 4565 iw = convert_to_FL_Coord(w) 4566 ih = convert_to_FL_Coord(h) 4567 it0 = convert_to_int(t0) 4568 idt = convert_to_int(dt) 4569 ulcolr = convert_to_FL_COLOR(colr) 4570 keep_elem_refs(fill, x, y, w, h, t0, dt, colr, ifill, ix, iy, iw, 4571 ih, it0, idt, ulcolr) 4572 _fl_ovalarc(ifill, ix, iy, iw, ih, it0, idt, ulcolr)
4573 4574
4575 -def fl_ovalf(x, y, w, h, colr):
4576 fl_oval(1, x, y, w, h, colr)
4577 4578
4579 -def fl_ovall(x, y, w, h, colr):
4580 fl_oval(0, x, y, w, h, colr)
4581 4582 4583 fl_oval_bound = fl_ovalbound 4584 4585
4586 -def fl_circf(x, y, r, colr):
4587 fl_oval(1, (x) - (r), (y) - (r), 2 * (r), 2 * (r), colr)
4588 4589
4590 -def fl_circ( x, y, r, colr):
4591 fl_oval(0, (x) - (r), (y) - (r), 2 * (r), 2 * (r), colr)
4592 4593 4594 # Arcs 4595
4596 -def fl_pieslice(fill, x, y, w, h, a1, a2, colr):
4597 """ fl_pieslice(fill, x, y, w, h, a1, a2, colr) 4598 """ 4599 4600 _fl_pieslice = cfuncproto( 4601 load_so_libforms(), "fl_pieslice",\ 4602 None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord,\ 4603 cty.c_int, cty.c_int, FL_COLOR],\ 4604 """void fl_pieslice(int fill, FL_Coord x, FL_Coord y, FL_Coord w, 4605 FL_Coord h, int a1, int a2, FL_COLOR col) 4606 """) 4607 check_admitted_listvalues(colr, COLOR_list) 4608 ifill = convert_to_int(fill) 4609 ix = convert_to_FL_Coord(x) 4610 iy = convert_to_FL_Coord(y) 4611 iw = convert_to_FL_Coord(w) 4612 ih = convert_to_FL_Coord(h) 4613 ia1 = convert_to_int(a1) 4614 ia2 = convert_to_int(a2) 4615 ulcolr = convert_to_FL_COLOR(colr) 4616 keep_elem_refs(fill, x, y, w, h, a1, a2, colr, ifill, ix, iy, iw, 4617 ih, ia1, ia2, ulcolr) 4618 _fl_pieslice(ifill, ix, iy, iw, ih, ia1, ia2, ulcolr)
4619 4620
4621 -def fl_arcf(x, y, r, a1, a2, colr):
4622 fl_pieslice(1, (x - r), (y - r), (2 * r), (2 * r), a1, a2, colr)
4623 4624
4625 -def fl_arc(x, y, r, a1, a2, colr):
4626 fl_pieslice(0, (x - r), (y - r), (2 * r), (2 * r), a1, a2, colr)
4627 4628 4629 # High level drawing routines 4630
4631 -def fl_drw_frame(style, x, y, w, h, colr, bw):
4632 """ fl_drw_frame(style, x, y, w, h, colr, bw) 4633 """ 4634 4635 _fl_drw_frame = cfuncproto( 4636 load_so_libforms(), "fl_drw_frame",\ 4637 None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord,\ 4638 FL_COLOR, cty.c_int],\ 4639 """void fl_drw_frame(int style, FL_Coord x, FL_Coord y, 4640 FL_Coord w, FL_Coord h, FL_COLOR c, int bw) 4641 """) 4642 check_admitted_listvalues(colr, COLOR_list) 4643 istyle = convert_to_int(style) 4644 ix = convert_to_FL_Coord(x) 4645 iy = convert_to_FL_Coord(y) 4646 iw = convert_to_FL_Coord(w) 4647 ih = convert_to_FL_Coord(h) 4648 ulcolr = convert_to_FL_COLOR(colr) 4649 ibw = convert_to_int(bw) 4650 keep_elem_refs(style, x, y, w, h, colr, bw, istyle, ix, iy, iw, 4651 ih, ulcolr, ibw) 4652 _fl_drw_frame(istyle, ix, iy, iw, ih, ulcolr, ibw)
4653 4654
4655 -def fl_drw_checkbox(boxtype, x, y, w, h, colr, bw):
4656 """ fl_drw_checkbox(boxtype, x, y, w, h, colr, bw) 4657 """ 4658 4659 _fl_drw_checkbox = cfuncproto( 4660 load_so_libforms(), "fl_drw_checkbox",\ 4661 None, [cty.c_int, FL_Coord, FL_Coord, FL_Coord, FL_Coord,\ 4662 FL_COLOR, cty.c_int],\ 4663 """void fl_drw_checkbox(int type, FL_Coord x, FL_Coord y, 4664 FL_Coord w, FL_Coord h, FL_COLOR col, int bw) 4665 """) 4666 check_admitted_listvalues(colr, COLOR_list) 4667 iboxtype = convert_to_int(boxtype) 4668 ix = convert_to_FL_Coord(x) 4669 iy = convert_to_FL_Coord(y) 4670 iw = convert_to_FL_Coord(w) 4671 ih = convert_to_FL_Coord(h) 4672 ulcolr = convert_to_FL_COLOR(colr) 4673 ibw = convert_to_int(bw) 4674 keep_elem_refs(boxtype, x, y, w, h, colr, bw, iboxtype, ix, iy, iw, 4675 ih, ulcolr, ibw) 4676 _fl_drw_checkbox(iboxtype, ix, iy, iw, ih, ulcolr, ibw)
4677 4678 4679 # Interfaces 4680
4681 -def fl_get_fontstruct(style, size):
4682 """ fl_get_fontstruct(style, size) -> XFontStruct class 4683 """ 4684 4685 _fl_get_fontstruct = cfuncproto( 4686 load_so_libforms(), "fl_get_fontstruct",\ 4687 cty.POINTER(XFontStruct), [cty.c_int, cty.c_int],\ 4688 """)XFontStruct * fl_get_fontstruct(int style, int size) 4689 """) 4690 istyle = convert_to_int(style) 4691 isize = convert_to_int(size) 4692 keep_elem_refs(style, size, istyle, isize) 4693 retval = _fl_get_fontstruct(istyle, isize) 4694 return retval
4695 4696 4697 fl_get_font_struct = fl_get_fontstruct 4698 fl_get_fntstruct = fl_get_font_struct 4699 4700 4701 #def fl_get_mouse(x, y, keymask) *API change*
4702 -def fl_get_mouse():
4703 """ fl_get_mouse() -> window, x, y, keymask 4704 """ 4705 4706 _fl_get_mouse = cfuncproto( 4707 load_so_libforms(), "fl_get_mouse",\ 4708 Window, [cty.POINTER(FL_Coord), cty.POINTER(FL_Coord),\ 4709 cty.POINTER(cty.c_uint)],\ 4710 """Window fl_get_mouse(FL_Coord * x, FL_Coord * y, 4711 unsigned int * keymask) 4712 """) 4713 x, px = make_FL_Coord_and_pointer() 4714 y, py = make_FL_Coord_and_pointer() 4715 keymask, pkeymask = make_uint_and_pointer() 4716 keep_elem_refs(x, y, keymask, px, py, pkeymask) 4717 retval = _fl_get_mouse(px, py, pkeymask) 4718 return retval, x, y, keymask
4719 4720
4721 -def fl_set_mouse(mx, my):
4722 """ fl_set_mouse(mx, my) 4723 """ 4724 4725 _fl_set_mouse = cfuncproto( 4726 load_so_libforms(), "fl_set_mouse",\ 4727 None, [FL_Coord, FL_Coord],\ 4728 """void fl_set_mouse(FL_Coord mx, FL_Coord my) 4729 """) 4730 imx = convert_to_int(mx) 4731 imy = convert_to_int(my) 4732 keep_elem_refs(mx, my, imx, imy) 4733 _fl_set_mouse(imx, imy)
4734 4735 4736 #def fl_get_win_mouse(win, x, y, keymask) *API change*
4737 -def fl_get_win_mouse(win):
4738 """ fl_get_win_mouse(win) -> window, x, y, keymask 4739 """ 4740 4741 _fl_get_win_mouse = cfuncproto( 4742 load_so_libforms(), "fl_get_win_mouse",\ 4743 Window, [Window, cty.POINTER(FL_Coord), cty.POINTER(FL_Coord),\ 4744 cty.POINTER(cty.c_uint)],\ 4745 """Window fl_get_win_mouse(Window win, FL_Coord * x, FL_Coord * y, 4746 unsigned int * keymask) 4747 """) 4748 ulwin = convert_to_Window(win) 4749 x, px = make_FL_Coord_and_pointer() 4750 y, py = make_FL_Coord_and_pointer() 4751 keymask, pkeymask = make_uint_and_pointer() 4752 keep_elem_refs(win, x, y, keymask, ulwin, px, py, pkeymask) 4753 retval = _fl_get_win_mouse(ulwin, px, py, pkeymask) 4754 return retval, x, y, keymask
4755 4756 4757 #def fl_get_form_mouse(fm, x, y, keymask) *API change*
4758 -def fl_get_form_mouse(pForm):
4759 """ fl_get_form_mouse(pForm) -> window, x, y, keymask 4760 4761 @param pForm : pointer to form 4762 """ 4763 4764 _fl_get_form_mouse = cfuncproto( 4765 load_so_libforms(), "fl_get_form_mouse",\ 4766 Window, [cty.POINTER(FL_FORM), cty.POINTER(FL_Coord),\ 4767 cty.POINTER(FL_Coord), cty.POINTER(cty.c_uint)],\ 4768 """Window fl_get_form_mouse(FL_FORM * fm, FL_Coord * x, 4769 FL_Coord * y, unsigned int * keymask) 4770 """) 4771 x, px = make_FL_Coord_and_pointer() 4772 y, py = make_FL_Coord_and_pointer() 4773 keymask, pkeymask = make_uint_and_pointer() 4774 keep_elem_refs(pForm, x, y, keymask) 4775 retval = _fl_get_form_mouse(pForm, px, py, pkeymask) 4776 return retval, x, y, keymask
4777 4778
4779 -def fl_win_to_form(win):
4780 """ 4781 fl_win_to_form(win) -> pForm 4782 4783 Returns the form that's shown in win. 4784 4785 @param win : window id whose form is shown 4786 """ 4787 4788 _fl_win_to_form = cfuncproto( 4789 load_so_libforms(), "fl_win_to_form", 4790 cty.POINTER(FL_FORM), [Window],\ 4791 """FL_FORM * fl_win_to_form(Window win) 4792 """) 4793 ulwin = convert_to_Window(win) 4794 keep_elem_refs(win, ulwin) 4795 retval = _fl_win_to_form(ulwin) 4796 return retval
4797 4798
4799 -def fl_set_form_icon(pForm, icon, mask):
4800 """ fl_set_form_icon(pForm, icon, mask) 4801 4802 @param pForm : pointer to form 4803 """ 4804 4805 _fl_set_form_icon = cfuncproto( 4806 load_so_libforms(), "fl_set_form_icon",\ 4807 None, [cty.POINTER(FL_FORM), Pixmap, Pixmap],\ 4808 """void fl_set_form_icon(FL_FORM * form, Pixmap p, Pixmap m) 4809 """) 4810 ulicon = convert_to_Pixmap(icon) 4811 ulmask = convert_to_Pixmap(mask) 4812 keep_elem_refs(pForm, icon, mask, ulicon, ulmask) 4813 _fl_set_form_icon(pForm, ulicon, ulmask)
4814 4815 4816 #def fl_get_decoration_sizes(pForm, top, right, bottom, left) *API change*
4817 -def fl_get_decoration_sizes(pForm):
4818 """ 4819 fl_get_decoration_sizes(pForm) -> num., top, right, bottom, left 4820 4821 Returns the sizes of the "decorations" the window manager puts around 4822 a form's window. Returns 0 on success and 1 if the form isn't visible 4823 or it's a form embedded into another form. 4824 4825 @param pForm : pointer to form 4826 """ 4827 4828 _fl_get_decoration_sizes = cfuncproto( 4829 load_so_libforms(), "fl_get_decoration_sizes", 4830 cty.c_int, [cty.POINTER(FL_FORM), cty.POINTER(cty.c_int),\ 4831 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 4832 cty.POINTER(cty.c_int)],\ 4833 """int fl_get_decoration_sizes(FL_FORM * form, int * top, 4834 int * right, int * bottom, int * left) 4835 """) 4836 top, ptop = make_int_and_pointer() 4837 right, pright = make_int_and_pointer() 4838 bottom, pbottom = make_int_and_pointer() 4839 left, pleft = make_int_and_pointer() 4840 keep_elem_refs(pForm, top, right, bottom, left, ptop, pright, pbottom, 4841 pleft) 4842 retval = _fl_get_decoration_sizes(pForm, ptop, pright, pbottom, pleft) 4843 return retval, top, right, bottom, left
4844 4845
4846 -def fl_raise_form(pForm):
4847 """ 4848 fl_raise_form(pForm) 4849 4850 @param pForm : pouinter to form to be raised 4851 """ 4852 4853 _fl_raise_form = cfuncproto( 4854 load_so_libforms(), "fl_raise_form",\ 4855 None, [cty.POINTER(FL_FORM)],\ 4856 """void fl_raise_form(FL_FORM * p1) 4857 """) 4858 keep_elem_refs(pForm) 4859 _fl_raise_form(pForm)
4860 4861
4862 -def fl_lower_form(pForm):
4863 """ 4864 fl_lower_form(pForm) 4865 4866 @param pForm : pouinter to form to be lowered 4867 """ 4868 4869 _fl_lower_form = cfuncproto( 4870 load_so_libforms(), "fl_lower_form",\ 4871 None, [cty.POINTER(FL_FORM)],\ 4872 """void fl_lower_form(FL_FORM * p1) 4873 """) 4874 keep_elem_refs(pForm) 4875 _fl_lower_form(pForm)
4876 4877
4878 -def fl_set_foreground(gc, colr):
4879 """ 4880 fl_set_foreground(gc, colr) 4881 4882 @param gc : ? 4883 @param colr : color value to be set as foreground 4884 """ 4885 4886 _fl_set_foreground = cfuncproto( 4887 load_so_libforms(), "fl_set_foreground",\ 4888 None, [GC, FL_COLOR],\ 4889 """oid fl_set_foreground(GC gc, FL_COLOR col) 4890 """) 4891 ulcolr = convert_to_FL_COLOR(colr) 4892 keep_elem_refs(gc, colr, ulcolr) 4893 _fl_set_foreground(gc, ulcolr)
4894 4895
4896 -def fl_set_background(gc, colr):
4897 """ 4898 fl_set_background(gc, colr) 4899 4900 @param gc : ? 4901 @param colr : color value to be set as background 4902 """ 4903 4904 _fl_set_background = cfuncproto( 4905 load_so_libforms(), "fl_set_background",\ 4906 None, [GC, FL_COLOR],\ 4907 """oid fl_set_background(GC gc, FL_COLOR col) 4908 """) 4909 ulcolr = convert_to_FL_COLOR(colr) 4910 keep_elem_refs(gc, colr, ulcolr) 4911 _fl_set_background(gc, ulcolr)
4912 4913 4914 # General windowing support 4915
4916 -def fl_wincreate(title):
4917 """ 4918 fl_wincreate(title) -> window ID 4919 4920 Creates a window with a specified title. 4921 4922 @param title : title of the window 4923 """ 4924 4925 _fl_wincreate = cfuncproto( 4926 load_so_libforms(), "fl_wincreate",\ 4927 Window, [STRING],\ 4928 """Window fl_wincreate(const char * label) 4929 """) 4930 stitle = convert_to_string(title) 4931 keep_elem_refs(title, stitle) 4932 retval = _fl_wincreate(stitle) 4933 return retval
4934 4935
4936 -def fl_winshow(win):
4937 """ 4938 fl_winshow(win) -> window 4939 4940 Shows the window (created with fl_wincreate) 4941 4942 @param win : window id to show 4943 """ 4944 4945 _fl_winshow = cfuncproto( 4946 load_so_libforms(), "fl_winshow",\ 4947 Window, [Window],\ 4948 """Window fl_winshow(Window win) 4949 """) 4950 ulwin = convert_to_Window(win) 4951 keep_elem_refs(win, ulwin) 4952 retval = _fl_winshow(ulwin) 4953 return retval
4954 4955
4956 -def fl_winopen(title):
4957 """ 4958 fl_winopen(title) -> window 4959 Opens (creates and shows) a toplevel window with the specified 4960 title. 4961 4962 @param title : title of the window 4963 """ 4964 4965 _fl_winopen = cfuncproto( 4966 load_so_libforms(), "fl_winopen", \ 4967 Window, [STRING], \ 4968 """Window fl_winopen(const char * label) 4969 """) 4970 stitle = convert_to_string(title) 4971 keep_elem_refs(title, stitle) 4972 retval = _fl_winopen(stitle) 4973 return retval
4974 4975
4976 -def fl_winhide(win):
4977 """ fl_winhide(win) 4978 """ 4979 4980 _fl_winhide = cfuncproto( 4981 load_so_libforms(), "fl_winhide", \ 4982 None, [Window], \ 4983 """void fl_winhide(Window win) 4984 """) 4985 ulwin = convert_to_Window(win) 4986 keep_elem_refs(win, ulwin) 4987 _fl_winhide(ulwin)
4988 4989
4990 -def fl_winclose(win):
4991 """ fl_winclose(win) 4992 """ 4993 4994 _fl_winclose = cfuncproto( 4995 load_so_libforms(), "fl_winclose", \ 4996 None, [Window], \ 4997 """void fl_winclose(Window win) 4998 """) 4999 ulwin = convert_to_Window(win) 5000 keep_elem_refs(win, ulwin) 5001 _fl_winclose(win, ulwin)
5002 5003
5004 -def fl_winset(win):
5005 """ fl_winset(win) 5006 """ 5007 5008 _fl_winset = cfuncproto( 5009 load_so_libforms(), "fl_winset", \ 5010 None, [Window], \ 5011 """void fl_winset(Window win) 5012 """) 5013 ulwin = convert_to_Window(win) 5014 keep_elem_refs(win, ulwin) 5015 _fl_winset(ulwin)
5016 5017
5018 -def fl_winreparent(win, winnewparent):
5019 """ 5020 fl_winreparent(win, winnewparent) -> num. 5021 5022 Makes a toplevel window a subwindow of another (new parent) window; 5023 both the window and the parent window must be valid ones. 5024 5025 @param win : window to be made a subwindow 5026 @param winnewparent : window to become its new parent window 5027 """ 5028 5029 _fl_winreparent = cfuncproto( 5030 load_so_libforms(), "fl_winreparent", \ 5031 cty.c_int, [Window, Window], \ 5032 """int fl_winreparent(Window win, Window new_parent) 5033 """) 5034 ulwin = convert_to_Window(win) 5035 ulwinnewparent = convert_to_Window(winnewparent) 5036 keep_elem_refs(win, winnewparent, ulwin, ulwinnewparent) 5037 retval = _fl_winreparent(ulwin, ulwinnewparent) 5038 return retval
5039 5040
5041 -def fl_winfocus(win):
5042 """ fl_winfocus(win) 5043 """ 5044 5045 _fl_winfocus = cfuncproto( 5046 load_so_libforms(), "fl_winfocus", \ 5047 None, [Window], \ 5048 """void fl_winfocus(Window win) 5049 """) 5050 ulwin = convert_to_Window(win) 5051 keep_elem_refs(win, ulwin) 5052 _fl_winfocus(ulwin)
5053 5054
5055 -def fl_winget():
5056 """ fl_winget() -> window 5057 """ 5058 5059 _fl_winget = cfuncproto( 5060 load_so_libforms(), "fl_winget", \ 5061 Window, [], \ 5062 """Window fl_winget() 5063 """) 5064 retval = _fl_winget() 5065 return retval
5066 5067
5068 -def fl_iconify(win):
5069 """ fl_iconify(win) -> num. 5070 """ 5071 5072 _fl_iconify = cfuncproto( 5073 load_so_libforms(), "fl_iconify", \ 5074 cty.c_int, [Window], \ 5075 """int fl_iconify(Window win) 5076 """) 5077 ulwin = convert_to_Window(win) 5078 keep_elem_refs(win, ulwin) 5079 retval = _fl_iconify(ulwin) 5080 return retval
5081 5082
5083 -def fl_winresize(win, neww, newh):
5084 """ fl_winresize(win, neww, newh) 5085 5086 @param win : window to resize 5087 @param neww : new width 5088 @param newh : new height 5089 """ 5090 5091 _fl_winresize = cfuncproto( 5092 load_so_libforms(), "fl_winresize", \ 5093 None, [Window, FL_Coord, FL_Coord], \ 5094 """void fl_winresize(Window win, FL_Coord neww, FL_Coord newh) 5095 """) 5096 ulwin = convert_to_Window(win) 5097 ineww = convert_to_int(neww) 5098 inewh = convert_to_int(newh) 5099 keep_elem_refs(win, neww, newh, ulwin, ineww, inewh) 5100 _fl_winresize(ulwin, ineww, inewh)
5101 5102
5103 -def fl_winmove(win, dx, dy):
5104 """ fl_winmove(win, dx, dy) 5105 5106 @param win : window to move to a new position 5107 @param dx : new horizontal position 5108 @param dy : new vertical position 5109 """ 5110 5111 _fl_winmove = cfuncproto( 5112 load_so_libforms(), "fl_winmove", \ 5113 None, [Window, FL_Coord, FL_Coord], \ 5114 """void fl_winmove(Window win, FL_Coord dx, FL_Coord dy) 5115 """) 5116 ulwin = convert_to_Window(win) 5117 idx = convert_to_int(dx) 5118 idy = convert_to_int(dy) 5119 keep_elem_refs(win, dx, dy, ulwin, idx, idy) 5120 _fl_winmove(ulwin, idx, idy)
5121 5122
5123 -def fl_winreshape(win, dx, dy, w, h):
5124 """ fl_winreshape(win, dx, dy, w, h) 5125 """ 5126 5127 _fl_winreshape = cfuncproto( 5128 load_so_libforms(), "fl_winreshape", \ 5129 None, [Window, FL_Coord, FL_Coord, FL_Coord, FL_Coord], \ 5130 """void fl_winreshape(Window win, FL_Coord dx, FL_Coord dy, 5131 FL_Coord w, FL_Coord h) 5132 """) 5133 ulwin = convert_to_Window(win) 5134 idx = convert_to_int(dx) 5135 idy = convert_to_int(dy) 5136 iw = convert_to_FL_Coord(w) 5137 ih = convert_to_FL_Coord(h) 5138 keep_elem_refs(win, dx, dy, w, h, ulwin, idx, idy, iw, ih) 5139 _fl_winreshape(ulwin, idx, idy, iw, ih)
5140 5141
5142 -def fl_winicon(win, icon, mask):
5143 """ 5144 fl_winicon(win, icon, mask) 5145 5146 Installs an icon for the window. 5147 5148 @param win : window 5149 @param icon : pixmap icon to be installed in window 5150 @param mask : mask 5151 """ 5152 5153 _fl_winicon = cfuncproto( 5154 load_so_libforms(), "fl_winicon", \ 5155 None, [Window, Pixmap, Pixmap], \ 5156 """void fl_winicon(Window win, Pixmap p, Pixmap m) 5157 """) 5158 ulwin = convert_to_Window(win) 5159 ulicon = convert_to_Pixmap(icon) 5160 ulmask = convert_to_Pixmap(mask) 5161 keep_elem_refs(win, icon, mask, ulwin, ulicon, ulmask) 5162 _fl_winicon(ulwin, ulicon, ulmask)
5163 5164
5165 -def fl_winbackground(win, bkcolr):
5166 """ 5167 fl_winbackground(win, bkcolr) 5168 5169 Sets the background of the window to a certain color. 5170 5171 @param win : window 5172 @param bkcolr : background color to be set 5173 """ 5174 5175 _fl_winbackground = cfuncproto( 5176 load_so_libforms(), "fl_winbackground", \ 5177 None, [Window, FL_COLOR], \ 5178 """void fl_winbackground(Window win, FL_COLOR bk) 5179 """) 5180 check_admitted_listvalues(bkcolr, COLOR_list) 5181 ulwin = convert_to_Window(win) 5182 ulbkcolr = convert_to_FL_COLOR(bkcolr) 5183 keep_elem_refs(win, bkcolr, ulwin, ulbkcolr) 5184 _fl_winbackground(ulwin, ulbkcolr)
5185 5186
5187 -def fl_winstepsize(win, dx, dy):
5188 """ fl_winstepsize(win, dx, dy) 5189 """ 5190 5191 _fl_winstepsize = cfuncproto( 5192 load_so_libforms(), "fl_winstepsize", \ 5193 None, [Window, FL_Coord, FL_Coord], \ 5194 """void fl_winstepsize(Window win, FL_Coord dx, FL_Coord dy) 5195 """) 5196 ulwin = convert_to_Window(win) 5197 idx = convert_to_int(dx) 5198 idy = convert_to_int(dy) 5199 keep_elem_refs(win, dx, dy, ulwin, idx, idy) 5200 _fl_winstepsize(ulwin, idx, idy)
5201 5202 5203 fl_winstepunit = fl_winstepsize 5204 fl_set_winstepunit = fl_winstepsize 5205 5206
5207 -def fl_winisvalid(win):
5208 """ fl_winisvalid(win) -> num. 5209 """ 5210 5211 _fl_winisvalid = cfuncproto( 5212 load_so_libforms(), "fl_winisvalid", \ 5213 cty.c_int, [Window], \ 5214 """int fl_winisvalid(Window win) 5215 """) 5216 ulwin = convert_to_Window(win) 5217 keep_elem_refs(win, ulwin) 5218 retval = _fl_winisvalid(ulwin) 5219 return retval
5220 5221
5222 -def fl_wintitle(win, title):
5223 """ 5224 fl_wintitle(win, title) 5225 5226 Changes the window title (and its associated icon title). 5227 5228 @param win : window 5229 @param title : window title to be set 5230 """ 5231 5232 _fl_wintitle = cfuncproto( 5233 load_so_libforms(), "fl_wintitle", \ 5234 None, [Window, STRING], \ 5235 """void fl_wintitle(Window win, const char * title) 5236 """) 5237 ulwin = convert_to_Window(win) 5238 stitle = convert_to_string(title) 5239 keep_elem_refs(win, title, ulwin, stitle) 5240 _fl_wintitle(ulwin, stitle)
5241 5242
5243 -def fl_winicontitle(win, title):
5244 """ 5245 fl_winicontitle(win, title) 5246 5247 Changes only the icon title for the window. 5248 5249 @param win : window 5250 @param title : icon title to be set 5251 """ 5252 5253 _fl_winicontitle = cfuncproto( 5254 load_so_libforms(), "fl_winicontitle", \ 5255 None, [Window, STRING], \ 5256 """void fl_winicontitle(Window win, const char * title) 5257 """) 5258 ulwin = convert_to_Window(win) 5259 stitle = convert_to_string(title) 5260 keep_elem_refs(win, title, ulwin, stitle) 5261 _fl_winicontitle(ulwin, stitle)
5262 5263
5264 -def fl_winposition(x, y):
5265 """ 5266 fl_winposition(x, y) 5267 5268 Sets the position of a window to be opened. 5269 5270 @param x : horizontal position of the window (upper-left corner) 5271 @param y : vertical position of the window (upper-left corner) 5272 """ 5273 5274 _fl_winposition = cfuncproto( 5275 load_so_libforms(), "fl_winposition", 5276 None, [FL_Coord, FL_Coord], 5277 """void fl_winposition(FL_Coord x, FL_Coord y) 5278 """) 5279 ix = convert_to_FL_Coord(x) 5280 iy = convert_to_FL_Coord(y) 5281 keep_elem_refs(x, y, ix, iy) 5282 _fl_winposition(ix, iy)
5283 5284 5285 fl_pref_winposition = fl_winposition 5286 fl_win_background = fl_winbackground 5287 fl_set_winstepunit = fl_winstepunit 5288 5289
5290 -def fl_winminsize(win, w, h):
5291 """ 5292 fl_winminsize(win, w, h) 5293 5294 Sets a constraint for a resizable window whose size will be within a 5295 range not less than minumum (before calling fl_winopen). 5296 5297 @param win : window to be set 5298 @param w : minimum width of window 5299 @param h : minimum height of window 5300 """ 5301 5302 _fl_winminsize = cfuncproto( 5303 load_so_libforms(), "fl_winminsize", 5304 None, [Window, FL_Coord, FL_Coord], 5305 """void fl_winminsize(Window win, FL_Coord w, FL_Coord h) 5306 """) 5307 ulwin = convert_to_Window(win) 5308 iw = convert_to_FL_Coord(w) 5309 ih = convert_to_FL_Coord(h) 5310 keep_elem_refs(win, w, h, ulwin, iw, ih) 5311 _fl_winminsize(ulwin, iw, ih)
5312 5313
5314 -def fl_winmaxsize(win, w, h):
5315 """ 5316 fl_winmaxsize(win, w, h) 5317 5318 Sets a constraint for a resizable window whose size will be within a 5319 range not bigger than maximum (before calling fl_winopen). 5320 5321 @param win : window to be set 5322 @param w : maximum width of window 5323 @param h : maximum height of window 5324 """ 5325 5326 _fl_winmaxsize = cfuncproto( 5327 load_so_libforms(), "fl_winmaxsize", 5328 None, [Window, FL_Coord, FL_Coord], 5329 """void fl_winmaxsize(Window win, FL_Coord w, FL_Coord h) 5330 """) 5331 ulwin = convert_to_Window(win) 5332 iw = convert_to_FL_Coord(w) 5333 ih = convert_to_FL_Coord(h) 5334 keep_elem_refs(win, w, h, ulwin, iw, ih) 5335 _fl_winmaxsize(ulwin, iw, ih)
5336 5337
5338 -def fl_winaspect(win, x, y):
5339 """ 5340 fl_winaspect(win, x, y) 5341 5342 Sets the aspect ratio of the window for later interactive resizing. 5343 5344 @param win : window to be set 5345 @param x : horizontal aspect ratio 5346 @param y : vertical aspect ratio 5347 """ 5348 5349 _fl_winaspect = cfuncproto( 5350 load_so_libforms(), "fl_winaspect", 5351 None, [Window, FL_Coord, FL_Coord], 5352 """void fl_winaspect(Window win, FL_Coord x, FL_Coord y) 5353 """) 5354 ulwin = convert_to_Window(win) 5355 ix = convert_to_FL_Coord(x) 5356 iy = convert_to_FL_Coord(y) 5357 keep_elem_refs(win, x, y, ulwin, ix, iy) 5358 _fl_winaspect(ulwin, ix, iy)
5359 5360
5361 -def fl_reset_winconstraints(win):
5362 """ fl_reset_winconstraints(win) 5363 """ 5364 5365 _fl_reset_winconstraints = cfuncproto( 5366 load_so_libforms(), "fl_reset_winconstraints", 5367 None, [Window], 5368 """void fl_reset_winconstraints(Window win) 5369 """) 5370 ulwin = convert_to_Window(win) 5371 keep_elem_refs(win) 5372 _fl_reset_winconstraints(ulwin)
5373 5374
5375 -def fl_winsize(w, h):
5376 """ 5377 fl_winsize(w, h) 5378 5379 Sets the preferred window size (before calling fl_winopen), and makes 5380 the window non-resizeable. 5381 5382 @param w : width of the window in pixels 5383 @param h : height of the window in pixels 5384 """ 5385 5386 _fl_winsize = cfuncproto( 5387 load_so_libforms(), "fl_winsize", 5388 None, [FL_Coord, FL_Coord], 5389 """void fl_winsize(FL_Coord w, FL_Coord h) 5390 """) 5391 iw = convert_to_FL_Coord(w) 5392 ih = convert_to_FL_Coord(h) 5393 keep_elem_refs(w, h, iw, ih) 5394 _fl_winsize(iw, ih)
5395 5396
5397 -def fl_initial_winsize(w, h):
5398 """ 5399 fl_initial_winsize(w, h) 5400 5401 Sets the preferred window size (before calling fl_winopen). 5402 5403 @param w : width of the window in pixels 5404 @param h : height of the window in pixels 5405 """ 5406 5407 _fl_initial_winsize = cfuncproto( 5408 load_so_libforms(), "fl_initial_winsize", 5409 None, [FL_Coord, FL_Coord], 5410 """void fl_initial_winsize(FL_Coord w, FL_Coord h) 5411 """) 5412 iw = convert_to_FL_Coord(w) 5413 ih = convert_to_FL_Coord(h) 5414 keep_elem_refs(w, h, iw, ih) 5415 _fl_initial_winsize(iw, ih)
5416 5417 5418 fl_pref_winsize = fl_winsize 5419 5420
5421 -def fl_initial_winstate(state):
5422 """ fl_initial_winstate(state) 5423 """ 5424 5425 _fl_initial_winstate = cfuncproto( 5426 load_so_libforms(), "fl_initial_winstate", 5427 None, [cty.c_int], 5428 """void fl_initial_winstate(int state) 5429 """) 5430 istate = convert_to_int(state) 5431 keep_elem_refs(state, istate) 5432 _fl_initial_winstate(istate)
5433 5434
5435 -def fl_create_colormap(pXVisualInfo, nfill):
5436 """ fl_create_colormap(pXVisualInfo, nfill) -> colormap 5437 """ 5438 5439 _fl_create_colormap = cfuncproto( 5440 load_so_libforms(), "fl_create_colormap", 5441 Colormap, [cty.POINTER(XVisualInfo), cty.c_int], 5442 """)Colormap fl_create_colormap(XVisualInfo * xv, int nfill) 5443 """) 5444 infill = convert_to_int(nfill) 5445 keep_elem_refs(pXVisualInfo, nfill, infill) 5446 retval = _fl_create_colormap(pXVisualInfo, infill) 5447 return retval
5448 5449
5450 -def fl_wingeometry(x, y, w, h):
5451 """ 5452 fl_wingeometry(x, y, w, h) 5453 5454 Sets the initial geometry (position and size) of the window to be 5455 opened; the window will not be resizable. 5456 5457 @param x : horizontal position of the window (upper-left corner) 5458 @param y : vertical position of the window (upper-left corner) 5459 @param w : width of the window in pixels 5460 @param h : height of the window in pixels 5461 """ 5462 5463 _fl_wingeometry = cfuncproto( 5464 load_so_libforms(), "fl_wingeometry", 5465 None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord], 5466 """void fl_wingeometry(FL_Coord x, FL_Coord y, FL_Coord w, 5467 FL_Coord h) 5468 """) 5469 ix = convert_to_FL_Coord(x) 5470 iy = convert_to_FL_Coord(y) 5471 iw = convert_to_FL_Coord(w) 5472 ih = convert_to_FL_Coord(h) 5473 keep_elem_refs(x, y, w, h, ix, iy, iw, ih) 5474 _fl_wingeometry(ix, iy, iw, ih)
5475 5476 5477 fl_pref_wingeometry = fl_wingeometry 5478 5479
5480 -def fl_initial_wingeometry(x, y, w, h):
5481 """ 5482 fl_initial_wingeometry(x, y, w, h) 5483 5484 Sets the initial geometry (position and size) of the window to be 5485 opened. 5486 5487 @param x : horizontal position of the window (upper-left corner) 5488 @param y : vertical position of the window (upper-left corner) 5489 @param w : width of the window in pixels 5490 @param h : height of the window in pixels 5491 """ 5492 5493 _fl_initial_wingeometry = cfuncproto( 5494 load_so_libforms(), "fl_initial_wingeometry", 5495 None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord], 5496 """void fl_initial_wingeometry(FL_Coord x, FL_Coord y, 5497 FL_Coord w, FL_Coord h) 5498 """) 5499 ix = convert_to_FL_Coord(x) 5500 iy = convert_to_FL_Coord(y) 5501 iw = convert_to_FL_Coord(w) 5502 ih = convert_to_FL_Coord(h) 5503 keep_elem_refs(x, y, w, h, ix, iy, iw, ih) 5504 _fl_initial_wingeometry(ix, iy, iw, ih)
5505 5506
5507 -def fl_noborder():
5508 """ 5509 fl_noborder() 5510 5511 Suppresses the window manager's decoration (before creating the 5512 window). 5513 """ 5514 5515 _fl_noborder = cfuncproto( 5516 load_so_libforms(), "fl_noborder", 5517 None, [], 5518 """void fl_noborder() 5519 """) 5520 _fl_noborder()
5521 5522
5523 -def fl_transient():
5524 """ 5525 fl_transient() 5526 5527 Makes a window a transient one (before creating the window). 5528 """ 5529 5530 _fl_transient = cfuncproto( 5531 load_so_libforms(), "fl_transient", 5532 None, [], \ 5533 """void fl_transient() 5534 """) 5535 _fl_transient()
5536 5537 5538 #def fl_get_winsize(win, w, h) *API change*
5539 -def fl_get_winsize(win):
5540 """ fl_get_winsize(win) -> width, height 5541 5542 @param win : window 5543 """ 5544 5545 _fl_get_winsize = cfuncproto( 5546 load_so_libforms(), "fl_get_winsize", 5547 None, [Window, cty.POINTER(FL_Coord), cty.POINTER(FL_Coord)], 5548 """void fl_get_winsize(Window win, FL_Coord * w, FL_Coord * h) 5549 """) 5550 ulwin = convert_to_Window(win) 5551 iw, pw = make_int_and_pointer() 5552 ih, ph = make_int_and_pointer() 5553 keep_elem_refs(win, ulwin, iw, ih, pw, ph) 5554 _fl_get_winsize(ulwin, pw, ph) 5555 return iw, ih
5556 5557 5558 #def fl_get_winorigin(win, x, y) *API change*
5559 -def fl_get_winorigin(win):
5560 """ fl_get_winorigin(win) -> x, y 5561 """ 5562 5563 _fl_get_winorigin = cfuncproto( 5564 load_so_libforms(), "fl_get_winorigin", 5565 None, [Window, cty.POINTER(FL_Coord), cty.POINTER(FL_Coord)], 5566 """void fl_get_winorigin(Window win, FL_Coord * x, FL_Coord * y) 5567 """) 5568 ulwin = convert_to_Window(win) 5569 x, px = make_FL_Coord_and_pointer() 5570 y, py = make_FL_Coord_and_pointer() 5571 keep_elem_refs(win, ulwin, x, y, px, py) 5572 _fl_get_winorigin(win, px, py) 5573 return x, y
5574 5575 5576 #def fl_get_wingeometry(win, x, y, w, h) *API change*
5577 -def fl_get_wingeometry(win):
5578 """ fl_get_wingeometry(win) -> x, y, w, h 5579 5580 @param win : window 5581 """ 5582 5583 _fl_get_wingeometry = cfuncproto( 5584 load_so_libforms(), "fl_get_wingeometry", 5585 None, [Window, cty.POINTER(FL_Coord), cty.POINTER(FL_Coord), 5586 cty.POINTER(FL_Coord), cty.POINTER(FL_Coord)], 5587 """void fl_get_wingeometry(Window win, FL_Coord * x, FL_Coord * y, 5588 FL_Coord * w, FL_Coord * h) 5589 """) 5590 ulwin = convert_to_Window(win) 5591 x, px = make_FL_Coord_and_pointer() 5592 y, py = make_FL_Coord_and_pointer() 5593 w, pw = make_FL_Coord_and_pointer() 5594 h, ph = make_FL_Coord_and_pointer() 5595 keep_elem_refs(win, x, y, w, h, ulwin, px, py, pw, ph) 5596 _fl_get_wingeometry(ulwin, px, py, pw, ph) 5597 return x, y, w, h
5598 5599 5600 # For compatibility 5601 fl_get_win_size = fl_get_winsize 5602 fl_get_win_origin = fl_get_winorigin 5603 fl_get_win_geometry = fl_get_wingeometry 5604 fl_initial_winposition = fl_pref_winposition 5605 5606
5607 -def fl_get_display(): # NOT SURE
5608 return fl_display 5609 5610
5611 -def FL_FormDisplay(pForm): # NOT SURE
5612 return fl_display 5613 5614
5615 -def FL_ObjectDisplay(object): # NOT SURE
5616 return fl_display 5617 5618
5619 -def FL_IS_CANVAS(pObject):
5620 if (pObject[0].objclass == FL_CANVAS) or \ 5621 (pObject[0].objclass == FL_GLCANVAS): 5622 return True 5623 else: 5624 return False
5625 5626 5627 # The window an object belongs to - for drawing
5628 -def FL_ObjWin(pObject):
5629 if FL_IS_CANVAS(pObject): 5630 return fl_get_canvas_id(pObject) 5631 else: 5632 return pObject[0].form[0].window
5633 5634
5635 -def fl_get_real_object_window(pObject):
5636 """ fl_get_real_object_window(pObject) -> window 5637 5638 @param pObject : pointer to object 5639 """ 5640 5641 _fl_get_real_object_window = cfuncproto( 5642 load_so_libforms(), "fl_get_real_object_window", 5643 Window, [cty.POINTER(FL_OBJECT)], 5644 """Window fl_get_real_object_window(FL_OBJECT * ob) 5645 """) 5646 keep_elem_refs(pObject) 5647 retval = _fl_get_real_object_window(pObject) 5648 return retval
5649 5650 5651 FL_OBJECT_WID = FL_ObjWin 5652 5653 5654 # Replacements for X functions that access the event queue 5655
5656 -def fl_XNextEvent(pXEvent):
5657 """ fl_XNextEvent(pXEvent) -> event num. 5658 """ 5659 5660 _fl_XNextEvent = cfuncproto( 5661 load_so_libforms(), "fl_XNextEvent", 5662 cty.c_int, [cty.POINTER(XEvent)], 5663 """int fl_XNextEvent(XEvent * xev) 5664 """) 5665 keep_elem_refs(pXEvent) 5666 retval = _fl_XNextEvent(pXEvent) 5667 return retval
5668 5669
5670 -def fl_XPeekEvent(pXEvent):
5671 """ fl_XPeekEvent(pXEvent) -> event num. 5672 """ 5673 5674 _fl_XPeekEvent = cfuncproto( 5675 load_so_libforms(), "fl_XPeekEvent", 5676 cty.c_int, [cty.POINTER(XEvent)], 5677 """int fl_XPeekEvent(XEvent * xev) 5678 """) 5679 keep_elem_refs(pXEvent) 5680 retval = _fl_XPeekEvent(pXEvent) 5681 return retval
5682 5683
5684 -def fl_XEventsQueued(mode):
5685 """ fl_XEventsQueued(mode) -> event num. 5686 """ 5687 5688 _fl_XEventsQueued = cfuncproto( 5689 load_so_libforms(), "fl_XEventsQueued", 5690 cty.c_int, [cty.c_int], 5691 """int fl_XEventsQueued(int mode) 5692 """) 5693 imode = convert_to_int(mode) 5694 keep_elem_refs(mode, imode) 5695 retval = _fl_XEventsQueued(imode) 5696 return retval
5697 5698
5699 -def fl_XPutBackEvent(pXEvent):
5700 """ fl_XPutBackEvent(pXEvent) 5701 """ 5702 5703 _fl_XPutBackEvent = cfuncproto( 5704 load_so_libforms(), "fl_XPutBackEvent", 5705 None, [cty.POINTER(XEvent)], 5706 """void fl_XPutBackEvent(XEvent * xev) 5707 """) 5708 keep_elem_refs(pXEvent) 5709 _fl_XPutBackEvent(pXEvent)
5710 5711
5712 -def fl_last_event():
5713 """ fl_last_event() -> event 5714 """ 5715 5716 _fl_last_event = cfuncproto( 5717 load_so_libforms(), "fl_last_event", 5718 cty.POINTER(XEvent), [], 5719 """const char * fl_last_event() 5720 """) 5721 retval = _fl_last_event() 5722 return retval
5723 5724 5725 FL_APPEVENT_CB = cty.CFUNCTYPE(cty.c_int, cty.POINTER(XEvent), cty.c_void_p) 5726
5727 -def fl_set_event_callback(py_AppEventCb, userdata):
5728 """ 5729 fl_set_event_callback(py_AppEventCb, userdata) -> event callback 5730 """ 5731 5732 _fl_set_event_callback = cfuncproto( 5733 load_so_libforms(), "fl_set_event_callback", 5734 FL_APPEVENT_CB, [FL_APPEVENT_CB, cty.c_void_p], 5735 """FL_APPEVENT_CB fl_set_event_callback(FL_APPEVENT_CB callback, 5736 void * user_data) 5737 """) 5738 c_AppEventCb = FL_APPEVENT_CB(py_AppEventCb) 5739 puserdata = cty.cast(userdata, cty.c_void_p) 5740 keep_cfunc_refs(c_AppEventCb, py_AppEventCb) 5741 keep_elem_refs(userdata, puserdata) 5742 retval = _fl_set_event_callback(c_AppEventCb, puserdata) 5743 return retval
5744 5745
5746 -def fl_set_idle_callback(py_AppEventCb, userdata):
5747 """ fl_set_idle_callback(py_AppEventCb, userdata) -> event callback func. 5748 """ 5749 5750 _fl_set_idle_callback = cfuncproto( 5751 load_so_libforms(), "fl_set_idle_callback", 5752 FL_APPEVENT_CB, [FL_APPEVENT_CB, cty.c_void_p], 5753 """FL_APPEVENT_CB fl_set_idle_callback(FL_APPEVENT_CB callback, 5754 void * user_data) 5755 """) 5756 c_AppEventCb = FL_APPEVENT_CB(py_AppEventCb) 5757 puserdata = cty.cast(userdata, cty.c_void_p) 5758 keep_cfunc_refs(c_AppEventCb, py_AppEventCb) 5759 keep_elem_refs(userdata, puserdata) 5760 retval = _fl_set_idle_callback(c_AppEventCb, puserdata) 5761 return retval
5762 5763
5764 -def fl_addto_selected_xevent(win, mask):
5765 """ fl_addto_selected_xevent(win, mask) -> num. 5766 """ 5767 5768 _fl_addto_selected_xevent = cfuncproto( 5769 load_so_libforms(), "fl_addto_selected_xevent", 5770 cty.c_long, [Window, cty.c_long], 5771 """long int fl_addto_selected_xevent(Window win, long int mask) 5772 """) 5773 ulwin = convert_to_Window(win) 5774 lmask = convert_to_long(mask) 5775 keep_elem_refs(win, mask, ulwin, lmask) 5776 retval = _fl_addto_selected_xevent(ulwin, lmask) 5777 return retval
5778 5779
5780 -def fl_remove_selected_xevent(win, mask):
5781 """ fl_remove_selected_xevent(win, mask) -> num. 5782 """ 5783 5784 _fl_remove_selected_xevent = cfuncproto( 5785 load_so_libforms(), "fl_remove_selected_xevent", 5786 cty.c_long, [Window, cty.c_long], 5787 """)long int fl_remove_selected_xevent(Window win, long int mask) 5788 """) 5789 ulwin = convert_to_Window(win) 5790 lmask = convert_to_long(mask) 5791 keep_elem_refs(win, mask, ulwin, lmask) 5792 retval = _fl_remove_selected_xevent(ulwin, lmask) 5793 return retval
5794 5795 5796 fl_add_selected_xevent = fl_addto_selected_xevent 5797 5798
5799 -def fl_set_idle_delta(delta):
5800 """ fl_set_idle_delta(delta) 5801 """ 5802 5803 _fl_set_idle_delta = cfuncproto( 5804 load_so_libforms(), "fl_set_idle_delta", 5805 None, [cty.c_long], 5806 """void fl_set_idle_delta(long int delta) 5807 """) 5808 ldelta = convert_to_long(delta) 5809 keep_elem_refs(delta, ldelta) 5810 _fl_set_idle_delta(ldelta)
5811 5812
5813 -def fl_add_event_callback(win, ev, py_AppEventCb, userdata):
5814 """ 5815 fl_add_event_callback(win, ev, py_AppEventCb, userdata) -> event callback 5816 5817 Adds an event handler for a window. 5818 5819 @param win : window id to add event handler to 5820 @param ev : event number 5821 @param py_AppEventCb : python function for handling event, fn(pXevent, 5822 ptr_void) -> num 5823 @param userdata : user data argument 5824 """ 5825 5826 _fl_add_event_callback = cfuncproto( 5827 load_so_libforms(), "fl_add_event_callback", 5828 FL_APPEVENT_CB, [Window, cty.c_int, FL_APPEVENT_CB, cty.c_void_p], 5829 """FL_APPEVENT_CB fl_add_event_callback(Window win, int ev, 5830 FL_APPEVENT_CB wincb, void * user_data) 5831 """) 5832 ulwin = convert_to_Window(win) 5833 iev = convert_to_int(ev) 5834 c_AppEventCb = FL_APPEVENT_CB(py_AppEventCb) 5835 puserdata = cty.cast(userdata, cty.c_void_p) 5836 keep_cfunc_refs(c_AppEventCb, py_AppEventCb) 5837 keep_elem_refs(win, ev, userdata, ulwin, iev, puserdata) 5838 retval = _fl_add_event_callback(ulwin, iev, c_AppEventCb, puserdata) 5839 return retval
5840 5841
5842 -def fl_remove_event_callback(win, ev):
5843 """ 5844 fl_remove_event_callback(win, ev) 5845 5846 Removes one or all event callbacks for a window. May be called 5847 with for a window for which no event callbacks have been set. 5848 5849 @param win : window id 5850 @param ev : evnet number 5851 """ 5852 5853 _fl_remove_event_callback = cfuncproto( 5854 load_so_libforms(), "fl_remove_event_callback", 5855 None, [Window, cty.c_int], 5856 """void fl_remove_event_callback(Window win, int ev) 5857 """) 5858 ulwin = convert_to_Window(win) 5859 iev = convert_to_int(ev) 5860 keep_elem_refs(win, ev, ulwin, iev) 5861 _fl_remove_event_callback(ulwin, iev)
5862 5863
5864 -def fl_activate_event_callbacks(win):
5865 """ fl_activate_event_callbacks(win) 5866 5867 @param win : window whose events are referred to 5868 """ 5869 5870 _fl_activate_event_callbacks = cfuncproto( 5871 load_so_libforms(), "fl_activate_event_callbacks", 5872 None, [Window], 5873 """void fl_activate_event_callbacks(Window win) 5874 """) 5875 ulwin = convert_to_Window(win) 5876 keep_elem_refs(win, ulwin) 5877 _fl_activate_event_callbacks(ulwin)
5878 5879
5880 -def fl_print_xevent_name(where, pXEvent):
5881 """ fl_print_xevent_name(where, pXEvent) -> pXEvent 5882 """ 5883 5884 _fl_print_xevent_name = cfuncproto( 5885 load_so_libforms(), "fl_print_xevent_name", 5886 cty.POINTER(XEvent), [STRING, cty.POINTER(XEvent)], 5887 """XEvent * fl_print_xevent_name(const char * where, 5888 const Xevent * xev) 5889 """) 5890 swhere = convert_to_string(where) 5891 keep_elem_refs(where, pXEvent, swhere) 5892 retval = _fl_print_xevent_name(swhere, pXEvent) 5893 return retval
5894 5895
5896 -def fl_XFlush():
5897 """ 5898 fl_XFlush() 5899 5900 Convenience replacement for XFlush() 5901 """ 5902 5903 _fl_XFlush = cfuncproto( 5904 load_so_libforms(), "fl_XFlush", 5905 None, [], 5906 """void fl_XFlush(void) 5907 """) 5908 _fl_XFlush()
5909 5910
5911 -def metakey_down(mask):
5912 return (mask & Mod1Mask)
5913 5914
5915 -def shiftkey_down(mask):
5916 return (mask & ShiftMask)
5917 5918
5919 -def controlkey_down(mask):
5920 return (mask & ControlMask)
5921 5922
5923 -def button_down(mask):
5924 if (mask & Button1Mask) or (mask & Button2Mask) or \ 5925 (mask & Button3Mask) or (mask & Button4Mask) or \ 5926 (mask & Button5Mask): 5927 return True 5928 else: 5929 return False
5930 5931 5932 # Resources 5933
5934 -def fl_initialize(lsysargv, sysargv, appclass, appopt, nappopt):
5935 """ fl_initialize(numargs, args, applclass, apploptions, numapplopts) -> pDisplay 5936 """ 5937 5938 _fl_initialize = cfuncproto( 5939 load_so_libforms(), "fl_initialize", 5940 cty.POINTER(Display), [cty.POINTER(cty.c_int), 5941 cty.POINTER(STRING), STRING, cty.POINTER(XrmOptionDescRec), 5942 cty.c_int], 5943 """Display * fl_initialize(int * na, char * * arg, 5944 const char * appclass, FL_CMD_OPT * appopt, int nappopt) 5945 """) 5946 verify_version_compatibility() # verify if installed XForms 5947 # is compatible with this one 5948 lsysargv = 1 5949 cliargs_nr = cty.c_int(lsysargv) #1 5950 cliargs_nr_p = cty.byref(cliargs_nr) 5951 argum = "".join(sysargv) 5952 scliargs = convert_to_string(argum) # " " 5953 sappclass = convert_to_string(appclass) 5954 structopts = cty.POINTER(FL_CMD_OPT)() 5955 keep_elem_refs(cliargs_nr_p, scliargs, appclass, sappclass, structopts, 5956 nappopt) 5957 retval = _fl_initialize(cliargs_nr_p, scliargs, sappclass, structopts, 5958 nappopt) 5959 return retval
5960 5961
5962 -def fl_finish():
5963 """ fl_finish() 5964 """ 5965 5966 _fl_finish = cfuncproto( 5967 load_so_libforms(), "fl_finish", 5968 None, [], 5969 """void fl_finish() 5970 """) 5971 _fl_finish()
5972 5973
5974 -def fl_get_resource(rname, cname, dtype, defval, val, size):
5975 """ fl_get_resource(rname, cname, dtype, defval, val, size) -> string 5976 """ 5977 5978 _fl_get_resource = cfuncproto( 5979 load_so_libforms(), "fl_get_resource", 5980 STRING, [STRING, STRING, FL_RTYPE, STRING, cty.c_void_p, 5981 cty.c_int], 5982 """const char * fl_get_resource(const char * rname, 5983 const char * cname, FL_RTYPE dtype, const char * defval, 5984 void * val, int size) 5985 """) 5986 srname = convert_to_string(rname) 5987 scname = convert_to_string(cname) 5988 idtype = convert_to_int(dtype) 5989 sdefval = convert_to_string(defval) 5990 pval = cty.cast(val, cty.c_void_p) 5991 isize = convert_to_int(size) 5992 keep_elem_refs(rname, cname, dtype, defval, val, size, srname, scname, 5993 idtype, sdefval, pval, isize) 5994 retval = _fl_get_resource(srname, scname, idtype, sdefval, pval, isize) 5995 return retval
5996 5997
5998 -def fl_set_resource(resstr, val):
5999 """ fl_set_resource(resstr, val) 6000 6001 @param resstr : resource name 6002 @param val : new string value for resource 6003 """ 6004 6005 _fl_set_resource = cfuncproto( 6006 load_so_libforms(), "fl_set_resource", 6007 None, [STRING, STRING], 6008 """void fl_set_resource(const char * str, const char * val) 6009 """) 6010 sresstr = convert_to_string(resstr) 6011 sval = convert_to_string(val) 6012 keep_elem_refs(resstr, val, sresstr, sval) 6013 _fl_set_resource(sresstr, sval)
6014 6015
6016 -def fl_get_app_resources(pResource, n):
6017 """ fl_get_app_resources(pResource, n) 6018 """ 6019 6020 _fl_get_app_resources = cfuncproto( 6021 load_so_libforms(), "fl_get_app_resources", 6022 None, [cty.POINTER(FL_RESOURCE), cty.c_int], 6023 """void fl_get_app_resources(FL_RESOURCE * appresource, int n) 6024 """) 6025 inum = convert_to_int(n) 6026 keep_elem_refs(pResource, n, inum) 6027 _fl_get_app_resources(pResource, inum)
6028 6029
6030 -def fl_set_graphics_mode(mode, doublebuf):
6031 """ fl_set_graphics_mode(mode, doublebuf) 6032 """ 6033 6034 _fl_set_graphics_mode = cfuncproto( 6035 load_so_libforms(), "fl_set_graphics_mode", 6036 None, [cty.c_int, cty.c_int], 6037 """void fl_set_graphics_mode(int mode, int doublebuf) 6038 """) 6039 imode = convert_to_int(mode) 6040 idoublebuf = convert_to_int(doublebuf) 6041 keep_elem_refs(mode, doublebuf, imode, idoublebuf) 6042 _fl_set_graphics_mode(imode, idoublebuf)
6043 6044
6045 -def fl_set_visualID(idnum):
6046 """ fl_set_visualID(idnum) 6047 """ 6048 6049 _fl_set_visualID = cfuncproto( 6050 load_so_libforms(), "fl_set_visualID", 6051 None, [cty.c_long], 6052 """void fl_set_visualID(long int id) 6053 """) 6054 lidnum = convert_to_long(idnum) 6055 keep_elem_refs(idnum, lidnum) 6056 _fl_set_visualID(lidnum)
6057 6058
6059 -def fl_keysym_pressed(keysym):
6060 """ fl_keysym_pressed(keysym) -> num. 6061 """ 6062 6063 _fl_keysym_pressed = cfuncproto( 6064 load_so_libforms(), "fl_keysym_pressed", 6065 cty.c_int, [KeySym], 6066 """int fl_keysym_pressed(KeySym k) 6067 """) 6068 ulkeysym = convert_to_ulong(keysym) 6069 keep_elem_refs(keysym, ulkeysym) 6070 retval = _fl_keysym_pressed(ulkeysym) 6071 return retval
6072 6073 6074 fl_keypressed = fl_keysym_pressed 6075 6076 6077 # Program default masks 6078
6079 -def fl_set_defaults(mask, pIopt):
6080 """ fl_set_defaults(mask, pIopt) 6081 """ 6082 6083 _fl_set_defaults = cfuncproto( 6084 load_so_libforms(), "fl_set_defaults", 6085 None, [cty.c_ulong, cty.POINTER(FL_IOPT)], 6086 """void fl_set_defaults(long unsigned int mask, FL_IOPT * cntl): 6087 """) 6088 ulmask = convert_to_ulong(mask) 6089 keep_elem_refs(mask, pIopt, ulmask) 6090 _fl_set_defaults(ulmask, pIopt)
6091 6092
6093 -def fl_set_tabstop(s):
6094 """ fl_set_tabstop(s) 6095 """ 6096 6097 _fl_set_tabstop = cfuncproto( 6098 load_so_libforms(), "fl_set_tabstop", 6099 None, [STRING], 6100 """void fl_set_tabstop(const char * s) 6101 """) 6102 ss = convert_to_string(s) 6103 keep_elem_refs(s, ss) 6104 _fl_set_tabstop(ss)
6105 6106
6107 -def fl_get_defaults(pIopt):
6108 """ fl_get_defaults(pIopt) 6109 """ 6110 6111 _fl_get_defaults = cfuncproto( 6112 load_so_libforms(), "fl_get_defaults", 6113 None, [cty.POINTER(FL_IOPT)], 6114 """void fl_get_defaults(FL_IOPT * cntl) 6115 """) 6116 keep_elem_refs(pIopt) 6117 _fl_get_defaults(pIopt)
6118 6119
6120 -def fl_get_visual_depth():
6121 """ fl_get_visual_depth() -> depth num. 6122 """ 6123 6124 _fl_get_visual_depth = cfuncproto( 6125 load_so_libforms(), "fl_get_visual_depth", 6126 cty.c_int, [], 6127 """int fl_get_visual_depth() 6128 """) 6129 retval = _fl_get_visual_depth() 6130 return retval
6131 6132
6133 -def fl_vclass_name(n):
6134 """ fl_vclass_name(n) -> name string 6135 """ 6136 6137 _fl_vclass_name = cfuncproto( 6138 load_so_libforms(), "fl_vclass_name", 6139 STRING, [cty.c_int], 6140 """const char * fl_vclass_name(int n) 6141 """) 6142 inum = convert_to_int(n) 6143 keep_elem_refs(n, inum) 6144 _fl_vclass_name(inum)
6145 6146
6147 -def fl_vclass_val(val):
6148 """ fl_vclass_val(val) -> num. 6149 """ 6150 6151 _fl_vclass_val = cfuncproto( 6152 load_so_libforms(), "fl_vclass_val", 6153 cty.c_int, [STRING], 6154 """int fl_vclass_val(const char * v) 6155 """) 6156 sval = convert_to_string(val) 6157 keep_elem_refs(val, sval) 6158 retval = _fl_vclass_val(sval) 6159 return retval
6160 6161
6162 -def fl_set_ul_property(prop, thickness):
6163 """ fl_set_ul_property(prop, thickness) 6164 """ 6165 6166 _fl_set_ul_property = cfuncproto( 6167 load_so_libforms(), "fl_set_ul_property", 6168 None, [cty.c_int, cty.c_int], 6169 """void fl_set_ul_property(int prop, int thickness) 6170 """) 6171 iprop = convert_to_int(prop) 6172 ithickness = convert_to_int(thickness) 6173 keep_elem_refs(prop, thickness, iprop, ithickness) 6174 _fl_set_ul_property(iprop, ithickness)
6175 6176
6177 -def fl_set_clipping(x, y, w, h):
6178 """ fl_set_clipping(x, y, w, h) 6179 """ 6180 6181 _fl_set_clipping = cfuncproto( 6182 load_so_libforms(), "fl_set_clipping", 6183 None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord], 6184 """void fl_set_clipping(FL_Coord x, FL_Coord y, FL_Coord w, 6185 FL_Coord h) 6186 """) 6187 ix = convert_to_FL_Coord(x) 6188 iy = convert_to_FL_Coord(y) 6189 iw = convert_to_FL_Coord(w) 6190 ih = convert_to_FL_Coord(h) 6191 keep_elem_refs(x, y, w, h, ix, iy, iw, ih) 6192 _fl_set_clipping(ix, iy, iw, ih)
6193 6194
6195 -def fl_set_gc_clipping(gc, x, y, w, h):
6196 """ fl_set_gc_clipping(gc, x, y, w, h) 6197 """ 6198 6199 _fl_set_gc_clipping = cfuncproto( 6200 load_so_libforms(), "fl_set_gc_clipping", 6201 None, [GC, FL_Coord, FL_Coord, FL_Coord, FL_Coord], 6202 """void fl_set_gc_clipping(GC gc, FL_Coord x, FL_Coord y, 6203 FL_Coord w, FL_Coord h) 6204 """) 6205 ix = convert_to_FL_Coord(x) 6206 iy = convert_to_FL_Coord(y) 6207 iw = convert_to_FL_Coord(w) 6208 ih = convert_to_FL_Coord(h) 6209 keep_elem_refs(gc, x, y, w, h, ix, iy, iw, ih) 6210 _fl_set_gc_clipping(gc, ix, iy, iw, ih)
6211 6212
6213 -def fl_unset_gc_clipping(gc):
6214 """ fl_unset_gc_clipping(gc) 6215 """ 6216 6217 _fl_unset_gc_clipping = cfuncproto( 6218 load_so_libforms(), "fl_unset_gc_clipping", 6219 None, [GC], 6220 """void fl_unset_gc_clipping(GC gc) 6221 """) 6222 keep_elem_refs(gc) 6223 _fl_unset_gc_clipping(gc)
6224 6225
6226 -def fl_set_clippings(pRect, n):
6227 """ fl_set_clippings(pRect, n) 6228 """ 6229 6230 _fl_set_clippings = cfuncproto( 6231 load_so_libforms(), "fl_set_clippings", 6232 None, [cty.POINTER(FL_RECT), cty.c_int], 6233 """void fl_set_clippings(FL_RECT * xrect, int n) 6234 """) 6235 inum = convert_to_int(n) 6236 keep_elem_refs(pRect, n, inum) 6237 _fl_set_clippings(pRect, inum)
6238 6239
6240 -def fl_unset_clipping():
6241 """ fl_unset_clipping() 6242 """ 6243 6244 _fl_unset_clipping = cfuncproto( 6245 load_so_libforms(), "fl_unset_clipping", 6246 None, [], 6247 """void fl_unset_clipping() 6248 """) 6249 _fl_unset_clipping()
6250 6251
6252 -def fl_set_text_clipping(x, y, w, h):
6253 """ fl_set_text_clipping(x, y, w, h) 6254 """ 6255 6256 _fl_set_text_clipping = cfuncproto( 6257 load_so_libforms(), "fl_set_text_clipping", 6258 None, [FL_Coord, FL_Coord, FL_Coord, FL_Coord], 6259 """void fl_set_text_clipping(FL_Coord x, FL_Coord y, FL_Coord w, 6260 FL_Coord h) 6261 """) 6262 ix = convert_to_FL_Coord(x) 6263 iy = convert_to_FL_Coord(y) 6264 iw = convert_to_FL_Coord(w) 6265 ih = convert_to_FL_Coord(h) 6266 keep_elem_refs(x, y, w, h, ix, iy, iw, ih) 6267 _fl_set_text_clipping(ix, iy, iw, ih)
6268 6269
6270 -def fl_unset_text_clipping():
6271 """ fl_unset_text_clipping() 6272 """ 6273 6274 _fl_unset_text_clipping = cfuncproto( 6275 load_so_libforms(), "fl_unset_text_clipping", 6276 None, [], 6277 """void fl_unset_text_clipping() 6278 """) 6279 _fl_unset_text_clipping()
6280 6281 6282 # How we pack and unpack colors 6283
6284 -def FL_PCCLAMP(a):
6285 if (a > FL_PCMAX): 6286 return FL_PCMAX 6287 elif (a < 0): 6288 return 0 6289 else: 6290 return a
6291 6292 6293 # If PCBITS is not 8, we need to apply the RGBmask 6294
6295 -def FL_GETR(packed):
6296 return ((packed >> FL_RSHIFT) & FL_RMASK)
6297 6298 # maybe unused in python?
6299 -def FL_GETG(packed):
6300 return ((packed) >> FL_GSHIFT) & FL_PCMAX
6301 6302 # maybe unused in python?
6303 -def FL_GETB(packed):
6304 return ((packed) >> FL_BSHIFT) & FL_PCMAX
6305 6306 # maybe unused in python?
6307 -def FL_GETA(packed):
6308 return ((packed) >> FL_ASHIFT) & FL_PCMAX
6309 6310 # maybe unused in python?
6311 -def FL_PACK3(r, g, b ):
6312 return (r<<FL_RSHIFT) | (g<<FL_GSHIFT) | (b<<FL_BSHIFT)
6313 6314 # maybe unused in python? 6315 FL_PACK = FL_PACK3 6316 6317 # maybe unused in python?
6318 -def FL_PACK4(r, g, b, a):
6319 return (FL_PACK3(r, g, b) | (a<<FL_ASHIFT))
6320 6321 # maybe unused in python?
6322 -def FL_UNPACK(p, r, g, b):
6323 r = FL_GETR(p) 6324 g = FL_GETG(p) 6325 b = FL_GETB(p) 6326 return r, g, b
6327 6328 # maybe unused in python? 6329 FL_UNPACK3 = FL_UNPACK 6330 6331 # maybe unused in python?
6332 -def FL_UNPACK4(p, r, g, b, a):
6333 r, g, b = FL_UNPACK3(p, r, g, b) 6334 a = FL_GETA(p) 6335 return r, g, b, a
6336 6337
6338 -def fl_popup_add(win, text):
6339 """ fl_popup_add(win, text) -> pPopup 6340 """ 6341 6342 _fl_popup_add = cfuncproto( 6343 load_so_libforms(), "fl_popup_add", 6344 cty.POINTER(FL_POPUP), [Window, STRING], 6345 """FL_POPUP * fl_popup_add(Window p1, const char * p2) 6346 """) 6347 ulwin = convert_to_Window(win) 6348 stext = convert_to_string(text) 6349 keep_elem_refs(win, text, ulwin, stext) 6350 retval = _fl_popup_add(ulwin, stext) 6351 return retval
6352 6353
6354 -def fl_popup_add_entries(pPopup, entrytxt):
6355 """ fl_popup_add_entries(pPopup, entrytxt) -> pPopupEntry 6356 """ 6357 6358 _fl_popup_add_entries = cfuncproto( 6359 load_so_libforms(), "fl_popup_add_entries", 6360 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), STRING], 6361 """FL_POPUP_ENTRY * fl_popup_add_entries(FL_POPUP * p1, 6362 const char * p2) 6363 """) 6364 sentrytxt = convert_to_string(entrytxt) 6365 keep_elem_refs(pPopup, entrytxt, sentrytxt) 6366 retval = _fl_popup_add_entries(pPopup, sentrytxt) 6367 return retval
6368 6369
6370 -def fl_popup_insert_entries(pPopup, pPopupEntry, entrytxt):
6371 """ fl_popup_insert_entries(pPopup, pPopupEntry, entrytxt) -> pPopupEntry 6372 """ 6373 6374 _fl_popup_insert_entries = cfuncproto( 6375 load_so_libforms(), "fl_popup_insert_entries", 6376 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), 6377 cty.POINTER(FL_POPUP_ENTRY), STRING], 6378 """FL_POPUP_ENTRY * fl_popup_insert_entries(FL_POPUP * p1, 6379 FL_POPUP_ENTRY * p2, const char * p3) 6380 """) 6381 sentrytxt = convert_to_string(entrytxt) 6382 keep_elem_refs(pPopup, pPopupEntry, entrytxt, sentrytxt) 6383 retval = _fl_popup_insert_entries(pPopup, pPopupEntry, sentrytxt) 6384 return retval
6385 6386
6387 -def fl_popup_create(win, text, pPopupItem):
6388 """ fl_popup_create(win, text, pPopupItem) -> pPopup 6389 """ 6390 6391 _fl_popup_create = cfuncproto( 6392 load_so_libforms(), "fl_popup_create", 6393 cty.POINTER(FL_POPUP), [Window, STRING, 6394 cty.POINTER(FL_POPUP_ITEM)], 6395 """FL_POPUP * fl_popup_create(Window p1, const char * p2, 6396 FL_POPUP_ITEM * p3) 6397 """) 6398 ulwin = convert_to_Window(win) 6399 stext = convert_to_string(text) 6400 keep_elem_refs(win, text, pPopupItem, ulwin, stext) 6401 retval = _fl_popup_create(ulwin, stext, pPopupItem) 6402 return retval
6403 6404
6405 -def fl_popup_delete(pPopup):
6406 """ fl_popup_delete(pPopup) -> num. 6407 """ 6408 6409 _fl_popup_delete = cfuncproto( 6410 load_so_libforms(), "fl_popup_delete", 6411 cty.c_int, [cty.POINTER(FL_POPUP)], 6412 """int fl_popup_delete(FL_POPUP * p1) 6413 """) 6414 keep_elem_refs(pPopup) 6415 retval = _fl_popup_delete(pPopup) 6416 return retval
6417 6418
6419 -def fl_popup_entry_delete(pPopupEntry):
6420 """ fl_popup_entry_delete(pPopupEntry) -> num. 6421 """ 6422 6423 _fl_popup_entry_delete = cfuncproto( 6424 load_so_libforms(), "fl_popup_entry_delete", 6425 cty.c_int, [cty.POINTER(FL_POPUP_ENTRY)], 6426 """int fl_popup_entry_delete(FL_POPUP_ENTRY * p1) 6427 """) 6428 keep_elem_refs(pPopupEntry) 6429 retval = _fl_popup_entry_delete(pPopupEntry) 6430 return retval
6431 6432
6433 -def fl_popup_do(pPopup):
6434 """ fl_popup_do(pPopup) -> pPopupReturn 6435 """ 6436 6437 _fl_popup_do = cfuncproto( 6438 load_so_libforms(), "fl_popup_do", 6439 cty.POINTER(FL_POPUP_RETURN), [cty.POINTER(FL_POPUP)], 6440 """FL_POPUP_RETURN * fl_popup_do(FL_POPUP * p1) 6441 """) 6442 keep_elem_refs(pPopup) 6443 retval = _fl_popup_do(pPopup) 6444 return retval
6445 6446
6447 -def fl_popup_set_position(pPopup, x, y):
6448 """ 6449 fl_popup_set_position(pPopup, x, y) 6450 6451 Sets position where the popup is supposed to appear (if never called 6452 the popup appears at the mouse position) 6453 6454 @param pPopup : pointer to Popup 6455 @param x : horizontal position (upper-left corner) 6456 @param y : vertical position (upper-left corner) 6457 """ 6458 6459 _fl_popup_set_position = cfuncproto( 6460 load_so_libforms(), "fl_popup_set_position", 6461 None, [cty.POINTER(FL_POPUP), cty.c_int, cty.c_int], 6462 """void fl_popup_set_position(FL_POPUP * p1, int p2, int p3) 6463 """) 6464 ix = convert_to_int(x) 6465 iy = convert_to_int(y) 6466 keep_elem_refs(pPopup, x, y, ix, iy) 6467 _fl_popup_set_position(pPopup, ix, iy)
6468 6469
6470 -def fl_popup_get_policy(pPopup):
6471 """ 6472 fl_popup_get_policy(pPopup) -> num. 6473 """ 6474 6475 _fl_popup_get_policy = cfuncproto( 6476 load_so_libforms(), "fl_popup_get_policy", 6477 cty.c_int, [cty.POINTER(FL_POPUP)], 6478 """int fl_popup_get_policy(FL_POPUP * p1) 6479 """) 6480 keep_elem_refs(pPopup) 6481 retval = _fl_popup_get_policy(pPopup) 6482 return retval
6483 6484
6485 -def fl_popup_set_policy(pPopup, policy):
6486 """ 6487 fl_popup_set_policy(pPopup, policy) -> num. 6488 6489 Sets policy of handling the popup (i.e. does it get closed when the 6490 user releases the mouse button outside an active entry or not?) 6491 6492 @param pPopup : pointer to Popup 6493 @param policy : policy to be set 6494 """ 6495 6496 _fl_popup_set_policy = cfuncproto( 6497 load_so_libforms(), "fl_popup_set_policy", 6498 cty.c_int, [cty.POINTER(FL_POPUP), cty.c_int], 6499 """int fl_popup_set_policy(FL_POPUP * p1, int p2) 6500 """) 6501 ipolicy = convert_to_int(policy) 6502 keep_elem_refs(pPopup, policy, ipolicy) 6503 retval = _fl_popup_set_policy(pPopup, ipolicy) 6504 return retval
6505 6506 6507 # already defined in xfdata 6508 #FL_POPUP_CB = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_POPUP_RETURN)) 6509
6510 -def fl_popup_set_callback(pPopup, py_PopupCb):
6511 """ 6512 fl_popup_set_callback(pPopup, py_PopupCb) -> popup callback func. 6513 """ 6514 6515 _fl_popup_set_callback = cfuncproto( 6516 load_so_libforms(), "fl_popup_set_callback", 6517 FL_POPUP_CB, [cty.POINTER(FL_POPUP), FL_POPUP_CB], 6518 """FL_POPUP_CB fl_popup_set_callback(FL_POPUP * p1, 6519 FL_POPUP_CB p2) 6520 """) 6521 c_PopupCb = FL_POPUP_CB(py_PopupCb) 6522 keep_cfunc_refs(c_PopupCb, py_PopupCb) 6523 keep_elem_refs(pPopup) 6524 retval = _fl_popup_set_callback(pPopup, c_PopupCb) 6525 return retval
6526 6527 6528 #def fl_popup_get_title_font(pPopup, style, size) *API change*
6529 -def fl_popup_get_title_font(pPopup):
6530 """ 6531 fl_popup_get_title_font(pPopup) -> style, size 6532 """ 6533 6534 _fl_popup_get_title_font = cfuncproto( 6535 load_so_libforms(), "fl_popup_get_title_font", 6536 None, [cty.POINTER(FL_POPUP), cty.POINTER(cty.c_int), 6537 cty.POINTER(cty.c_int)], 6538 """void fl_popup_get_title_font(FL_POPUP * p1, int * p2, 6539 int * p3) 6540 """) 6541 style, pstyle = make_int_and_pointer() 6542 size, psize = make_int_and_pointer() 6543 keep_elem_refs(pPopup, style, size, pstyle, psize) 6544 _fl_popup_get_title_font(pPopup, pstyle, psize) 6545 return style, size
6546 6547
6548 -def fl_popup_set_title_font(pPopup, style, size):
6549 """ 6550 fl_popup_set_title_font(pPopup, style, size) 6551 """ 6552 6553 _fl_popup_set_title_font = cfuncproto( 6554 load_so_libforms(), "fl_popup_set_title_font", 6555 None, [cty.POINTER(FL_POPUP), cty.c_int, cty.c_int], 6556 """void fl_popup_set_title_font(FL_POPUP * p1, int p2, int p3) 6557 """) 6558 istyle = convert_to_int(style) 6559 isize = convert_to_int(size) 6560 keep_elem_refs(pPopup, style, size, istyle, isize) 6561 _fl_popup_set_title_font(pPopup, istyle, isize)
6562 6563 6564 #def fl_popup_entry_get_font(pPopup, style, size) *API change*
6565 -def fl_popup_entry_get_font(pPopup):
6566 """ 6567 fl_popup_entry_get_font(pPopup) -> style, size 6568 """ 6569 6570 _fl_popup_entry_get_font = cfuncproto( 6571 load_so_libforms(), "fl_popup_entry_get_font", 6572 None, [cty.POINTER(FL_POPUP), cty.POINTER(cty.c_int), 6573 cty.POINTER(cty.c_int)], 6574 """void fl_popup_entry_get_font(FL_POPUP * p1, int * p2, int * p3) 6575 """) 6576 style, pstyle = make_int_and_pointer() 6577 size, psize = make_int_and_pointer() 6578 keep_elem_refs(pPopup, style, size, pstyle, psize) 6579 _fl_popup_entry_get_font(pPopup, pstyle, psize) 6580 return style, size
6581 6582
6583 -def fl_popup_entry_set_font(pPopup, style, size):
6584 """ 6585 fl_popup_entry_set_font(pPopup, style, size) 6586 6587 Sets the font of a popup entry. 6588 6589 @param pPopup : pointer to Popup 6590 @param style : style of the popup entry 6591 @param size : size of the popup entry 6592 """ 6593 6594 _fl_popup_entry_set_font = cfuncproto( 6595 load_so_libforms(), "fl_popup_entry_set_font", 6596 None, [cty.POINTER(FL_POPUP), cty.c_int, cty.c_int], 6597 """void fl_popup_entry_set_font(FL_POPUP * p1, int p2, int p3) 6598 """) 6599 istyle = convert_to_int(style) 6600 isize = convert_to_int(size) 6601 keep_elem_refs(pPopup, style, size, istyle, isize) 6602 _fl_popup_entry_set_font(pPopup, istyle, isize)
6603 6604
6605 -def fl_popup_get_bw(pPopup):
6606 """ 6607 fl_popup_get_bw(pPopup) -> borderwidth 6608 6609 Returns the border width of a popup. 6610 6611 @param pPopup : pointer to popup 6612 """ 6613 6614 _fl_popup_get_bw = cfuncproto( 6615 load_so_libforms(), "fl_popup_get_bw", 6616 cty.c_int, [cty.POINTER(FL_POPUP)], 6617 """int fl_popup_get_bw(FL_POPUP * p1) 6618 """) 6619 keep_elem_refs(pPopup) 6620 retval = _fl_popup_get_bw(pPopup) 6621 return retval
6622 6623
6624 -def fl_popup_set_bw(pPopup, bw):
6625 """ 6626 fl_popup_set_bw(pPopup, bw) -> num. 6627 6628 Sets the border width of a popup. 6629 6630 @param pPopup : pointer to popup 6631 @param bw : border width value to be set 6632 """ 6633 6634 _fl_popup_set_bw = cfuncproto( 6635 load_so_libforms(), "fl_popup_set_bw", 6636 cty.c_int, [cty.POINTER(FL_POPUP), cty.c_int], 6637 """int fl_popup_set_bw(FL_POPUP * p1, int p2) 6638 """) 6639 ibw = convert_to_int(bw) 6640 keep_elem_refs(pPopup, bw, ibw) 6641 retval = _fl_popup_set_bw(pPopup, ibw) 6642 return retval
6643 6644
6645 -def fl_popup_get_color(pPopup, p2):
6646 """ 6647 fl_popup_get_color(pPopup, p2) -> color 6648 """ 6649 6650 _fl_popup_get_color = cfuncproto( 6651 load_so_libforms(), "fl_popup_get_color", 6652 FL_COLOR, [cty.POINTER(FL_POPUP), cty.c_int], 6653 """FL_COLOR fl_popup_get_color(FL_POPUP * p1, int p2) 6654 """) 6655 ip2 = convert_to_int(p2) 6656 keep_elem_refs(pPopup, p2, ip2) 6657 retval = _fl_popup_get_color(pPopup, ip2) 6658 return retval
6659 6660
6661 -def fl_popup_set_color(pPopup, p2, colr):
6662 """ fl_popup_set_color(pPopup, p2, colr) -> color 6663 """ 6664 6665 _fl_popup_set_color = cfuncproto( 6666 load_so_libforms(), "fl_popup_set_color", 6667 FL_COLOR, [cty.POINTER(FL_POPUP), cty.c_int, FL_COLOR], 6668 """FL_COLOR fl_popup_set_color(FL_POPUP * p1, int p2, FL_COLOR p3) 6669 """) 6670 check_admitted_listvalues(colr, COLOR_list) 6671 ip2 = convert_to_int(p2) 6672 ulcolr = convert_to_FL_COLOR(colr) 6673 keep_elem_refs(pPopup, p2, colr, ip2, ulcolr) 6674 retval = _fl_popup_set_color(pPopup, ip2, ulcolr) 6675 return retval
6676 6677
6678 -def fl_popup_set_cursor(pPopup, cursnum):
6679 """ 6680 fl_popup_set_cursor(pPopup, cursnum) 6681 """ 6682 6683 _fl_popup_set_cursor = cfuncproto( 6684 load_so_libforms(), "fl_popup_set_cursor", 6685 None, [cty.POINTER(FL_POPUP), cty.c_int], 6686 """void fl_popup_set_cursor(FL_POPUP * p1, int p2) 6687 """) 6688 icursnum = convert_to_int(cursnum) 6689 keep_elem_refs(pPopup, cursnum, icursnum) 6690 _fl_popup_set_cursor(pPopup, icursnum)
6691 6692
6693 -def fl_popup_get_title(pPopup):
6694 """ 6695 fl_popup_get_title(pPopup) -> title string 6696 6697 Returns the title of a popup. 6698 6699 @param pPopup : pointer to popup 6700 """ 6701 6702 _fl_popup_get_title = cfuncproto( 6703 load_so_libforms(), "fl_popup_get_title", 6704 STRING, [cty.POINTER(FL_POPUP)], 6705 """const char * fl_popup_get_title(FL_POPUP * p1) 6706 """) 6707 keep_elem_refs(pPopup) 6708 retval = _fl_popup_get_title(pPopup) 6709 return retval
6710 6711
6712 -def fl_popup_set_title(pPopup, title):
6713 """ fl_popup_set_title(pPopup, title) -> popup 6714 6715 Sets the title of a popup. 6716 6717 @param pPopup : pointer to popup 6718 @param title : title of the popup 6719 """ 6720 6721 _fl_popup_set_title = cfuncproto( 6722 load_so_libforms(), "fl_popup_set_title", 6723 cty.POINTER(FL_POPUP), [cty.POINTER(FL_POPUP), STRING], 6724 """FL_POPUP * fl_popup_set_title(FL_POPUP * p1, const char * p2) 6725 """) 6726 stitle = convert_to_string(title) 6727 keep_elem_refs(pPopup, title, stitle) 6728 retval = _fl_popup_set_title(pPopup, stitle) 6729 return retval
6730 6731
6732 -def fl_popup_entry_set_callback(pPopupEntry, py_PopupCb):
6733 """ fl_popup_entry_set_callback(pPopupEntry, py_PopupCb) -> popup_callback 6734 """ 6735 6736 _fl_popup_entry_set_callback = cfuncproto( 6737 load_so_libforms(), "fl_popup_entry_set_callback", 6738 FL_POPUP_CB, [cty.POINTER(FL_POPUP_ENTRY), FL_POPUP_CB], 6739 """FL_POPUP_CB fl_popup_entry_set_callback(FL_POPUP_ENTRY * p1, 6740 FL_POPUP_CB p2) 6741 """) 6742 c_PopupCb = FL_POPUP_CB(py_PopupCb) 6743 keep_cfunc_refs(c_PopupCb, py_PopupCb) 6744 keep_elem_refs(pPopupEntry) 6745 retval = _fl_popup_entry_set_callback(pPopupEntry, c_PopupCb) 6746 return retval
6747 6748
6749 -def fl_popup_entry_set_enter_callback(pPopupEntry, py_PopupCb):
6750 """ fl_popup_entry_set_enter_callback(pPopupEntry, py_PopupCb) -> popup_callback 6751 """ 6752 6753 _fl_popup_entry_set_enter_callback = cfuncproto( 6754 load_so_libforms(), "fl_popup_entry_set_enter_callback", 6755 FL_POPUP_CB, [cty.POINTER(FL_POPUP_ENTRY), FL_POPUP_CB], 6756 """FL_POPUP_CB fl_popup_entry_set_enter_callback( 6757 FL_POPUP_ENTRY * p1, FL_POPUP_CB p2) 6758 """) 6759 c_PopupCb = FL_POPUP_CB(py_PopupCb) 6760 keep_cfunc_refs(c_PopupCb, py_PopupCb) 6761 keep_elem_refs(pPopupEntry) 6762 retval = _fl_popup_entry_set_enter_callback(pPopupEntry, c_PopupCb) 6763 return retval
6764 6765
6766 -def fl_popup_entry_set_leave_callback(pPopupEntry, py_PopupCb):
6767 """ fl_popup_entry_set_leave_callback(pPopupEntry, py_PopupCb) -> popup_callback 6768 """ 6769 6770 _fl_popup_entry_set_leave_callback = cfuncproto( 6771 load_so_libforms(), "fl_popup_entry_set_leave_callback", 6772 FL_POPUP_CB, [cty.POINTER(FL_POPUP_ENTRY), FL_POPUP_CB], 6773 """FL_POPUP_CB fl_popup_entry_set_leave_callback( 6774 FL_POPUP_ENTRY * p1, FL_POPUP_CB p2) 6775 """) 6776 c_PopupCb = FL_POPUP_CB(py_PopupCb) 6777 keep_cfunc_refs(c_PopupCb, py_PopupCb) 6778 keep_elem_refs(pPopupEntry) 6779 retval = _fl_popup_entry_set_leave_callback(pPopupEntry, c_PopupCb) 6780 return retval
6781 6782
6783 -def fl_popup_entry_get_state(pPopupEntry):
6784 """ fl_popup_entry_get_state(pPopupEntry) -> state num. 6785 """ 6786 6787 _fl_popup_entry_get_state = cfuncproto( 6788 load_so_libforms(), "fl_popup_entry_get_state", 6789 cty.c_uint, [cty.POINTER(FL_POPUP_ENTRY)], 6790 """unsigned int fl_popup_entry_get_state(FL_POPUP_ENTRY * p1) 6791 """) 6792 keep_elem_refs(pPopupEntry) 6793 retval = _fl_popup_entry_get_state(pPopupEntry) 6794 return retval
6795 6796
6797 -def fl_popup_entry_set_state(pPopupEntry, state):
6798 """ fl_popup_entry_set_state(pPopupEntry, state) -> state num. 6799 """ 6800 6801 _fl_popup_entry_set_state = cfuncproto( 6802 load_so_libforms(), "fl_popup_entry_set_state", 6803 cty.c_uint, [cty.POINTER(FL_POPUP_ENTRY), cty.c_uint], 6804 """unsigned int fl_popup_entry_set_state(FL_POPUP_ENTRY * p1, 6805 unsigned int p2) 6806 """) 6807 uistate = convert_to_uint(state) 6808 keep_elem_refs(pPopupEntry, state, uistate) 6809 retval = _fl_popup_entry_set_state(pPopupEntry, uistate) 6810 return retval
6811 6812
6813 -def fl_popup_entry_clear_state(pPopupEntry, state):
6814 """ fl_popup_entry_clear_state(pPopupEntry, state) -> state num. 6815 """ 6816 6817 _fl_popup_entry_clear_state = cfuncproto( 6818 load_so_libforms(), "fl_popup_entry_clear_state", 6819 cty.c_uint, [cty.POINTER(FL_POPUP_ENTRY), cty.c_uint], 6820 """unsigned int fl_popup_entry_clear_state(FL_POPUP_ENTRY * p1, 6821 unsigned int p2) 6822 """) 6823 uistate = convert_to_uint(state) 6824 keep_elem_refs(pPopupEntry, state, uistate) 6825 retval = _fl_popup_entry_clear_state(pPopupEntry, uistate) 6826 return retval
6827 6828
6829 -def fl_popup_entry_raise_state(pPopupEntry, state):
6830 """ fl_popup_entry_raise_state(pPopupEntry, state) -> state num. 6831 """ 6832 6833 _fl_popup_entry_raise_state = cfuncproto( 6834 load_so_libforms(), "fl_popup_entry_raise_state", 6835 cty.c_uint, [cty.POINTER(FL_POPUP_ENTRY), cty.c_uint], 6836 """unsigned int fl_popup_entry_raise_state(FL_POPUP_ENTRY * p1, 6837 unsigned int p2) 6838 """) 6839 uistate = convert_to_uint(state) 6840 keep_elem_refs(pPopupEntry, state, uistate) 6841 retval = _fl_popup_entry_raise_state(pPopupEntry, uistate) 6842 return retval
6843 6844
6845 -def fl_popup_entry_toggle_state(pPopupEntry, state):
6846 """ fl_popup_entry_toggle_state(pPopupEntry, state) -> num. 6847 """ 6848 6849 _fl_popup_entry_toggle_state = cfuncproto( 6850 load_so_libforms(), "fl_popup_entry_toggle_state", 6851 cty.c_uint, [cty.POINTER(FL_POPUP_ENTRY), cty.c_uint], 6852 """unsigned int fl_popup_entry_toggle_state(FL_POPUP_ENTRY * p1, 6853 unsigned int p2) 6854 """) 6855 uistate = convert_to_uint(state) 6856 keep_elem_refs(pPopupEntry, state, uistate) 6857 retval = _fl_popup_entry_toggle_state(pPopupEntry, uistate) 6858 return retval
6859 6860
6861 -def fl_popup_entry_set_text(pPopupEntry, text):
6862 """ fl_popup_entry_set_text(p1, txtstr) -> num. 6863 """ 6864 6865 _fl_popup_entry_set_text = cfuncproto( 6866 load_so_libforms(), "fl_popup_entry_set_text", 6867 cty.c_int, [cty.POINTER(FL_POPUP_ENTRY), STRING], 6868 """int fl_popup_entry_set_text(FL_POPUP_ENTRY * p1, 6869 const char * p2) 6870 """) 6871 stext = convert_to_string(text) 6872 keep_elem_refs(pPopupEntry, text, stext) 6873 retval = _fl_popup_entry_set_text(pPopupEntry, stext) 6874 return retval
6875 6876
6877 -def fl_popup_entry_set_shortcut(pPopupEntry, textsc):
6878 """ fl_popup_entry_set_shortcut(pPopupEntry, textsc) 6879 """ 6880 6881 _fl_popup_entry_set_shortcut = cfuncproto( 6882 load_so_libforms(), "fl_popup_entry_set_shortcut", 6883 None, [cty.POINTER(FL_POPUP_ENTRY), STRING], 6884 """void fl_popup_entry_set_shortcut(FL_POPUP_ENTRY * p1, 6885 const char * p2) 6886 """) 6887 stextsc = convert_to_string(textsc) 6888 keep_elem_refs(pPopupEntry, textsc, stextsc) 6889 _fl_popup_entry_set_shortcut(pPopupEntry, stextsc)
6890 6891
6892 -def fl_popup_entry_set_value(pPopupEntry, val):
6893 """ fl_popup_entry_set_value(pPopupEntry, p2) -> num. 6894 """ 6895 6896 _fl_popup_entry_set_value = cfuncproto( 6897 load_so_libforms(), "fl_popup_entry_set_value", 6898 cty.c_long, [cty.POINTER(FL_POPUP_ENTRY), cty.c_long], 6899 """long int fl_popup_entry_set_value(FL_POPUP_ENTRY * p1, 6900 long int p2) 6901 """) 6902 lval = convert_to_long(val) 6903 keep_elem_refs(pPopupEntry, val, lval) 6904 retval = _fl_popup_entry_set_value(pPopupEntry, lval) 6905 return retval
6906 6907
6908 -def fl_popup_entry_set_user_data(pPopupEntry, data):
6909 """ fl_popup_entry_set_user_data(pPopupEntry, data) -> ?? 6910 """ 6911 6912 _fl_popup_entry_set_user_data = cfuncproto( 6913 load_so_libforms(), "fl_popup_entry_set_user_data", 6914 cty.c_void_p, [cty.POINTER(FL_POPUP_ENTRY), cty.c_void_p], 6915 """void * fl_popup_entry_set_user_data(FL_POPUP_ENTRY * p1, 6916 void * p2) 6917 """) 6918 pdata = cty.cast(data, cty.c_void_p) 6919 keep_elem_refs(pPopupEntry, data, pdata) 6920 retval = _fl_popup_entry_set_user_data(pPopupEntry, pdata) 6921 return retval
6922 6923
6924 -def fl_popup_entry_get_by_position(pPopup, numpos):
6925 """ fl_popup_entry_get_by_position(pPopup, numpos) -> pPopupEntry 6926 """ 6927 6928 _fl_popup_entry_get_by_position = cfuncproto( 6929 load_so_libforms(), "fl_popup_entry_get_by_position", 6930 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), cty.c_int], 6931 """FL_POPUP_ENTRY * fl_popup_entry_get_by_position(FL_POPUP * p1, 6932 int p2) 6933 """) 6934 inumpos = convert_to_int(numpos) 6935 keep_elem_refs(pPopup, numpos, inumpos) 6936 retval = _fl_popup_entry_get_by_position(pPopup, inumpos) 6937 return retval
6938 6939
6940 -def fl_popup_entry_get_by_value(pPopup, val):
6941 """ fl_popup_entry_get_by_value(pPopup, val) -> pPopupEntry 6942 """ 6943 6944 _fl_popup_entry_get_by_value = cfuncproto( 6945 load_so_libforms(), "fl_popup_entry_get_by_value", 6946 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), cty.c_long], 6947 """FL_POPUP_ENTRY * fl_popup_entry_get_by_value(FL_POPUP * p1, 6948 long int p2) 6949 """) 6950 lval = convert_to_long(val) 6951 keep_elem_refs(pPopup, val, lval) 6952 retval = _fl_popup_entry_get_by_value(pPopup, lval) 6953 return retval
6954 6955
6956 -def fl_popup_entry_get_by_user_data(pPopup, userdata):
6957 """ fl_popup_entry_get_by_user_data(pPopup, userdata) -> pPopupEntry 6958 """ 6959 6960 _fl_popup_entry_get_by_user_data = cfuncproto( 6961 load_so_libforms(), "fl_popup_entry_get_by_user_data", 6962 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), cty.c_void_p], 6963 """FL_POPUP_ENTRY * fl_popup_entry_get_by_user_data(FL_POPUP * p1, 6964 void * p2) 6965 """) 6966 puserdata = cty.cast(userdata, cty.c_void_p) 6967 keep_elem_refs(pPopup, userdata, puserdata) 6968 retval = _fl_popup_entry_get_by_user_data(pPopup, puserdata) 6969 return retval
6970 6971
6972 -def fl_popup_entry_get_by_text(pPopup, text):
6973 """ fl_popup_entry_get_by_text(pPopup, text) -> pPopupEntry 6974 """ 6975 6976 _fl_popup_entry_get_by_text = cfuncproto( 6977 load_so_libforms(), "fl_popup_entry_get_by_text", 6978 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), STRING], 6979 """FL_POPUP_ENTRY * fl_popup_entry_get_by_text(FL_POPUP * p1, 6980 const char * p2) 6981 """) 6982 stext = convert_to_string(text) 6983 keep_elem_refs(pPopup, text, stext) 6984 retval = _fl_popup_entry_get_by_text(pPopup, stext) 6985 return retval
6986 6987
6988 -def fl_popup_entry_get_by_label(pPopup, label):
6989 """ fl_popup_entry_get_by_label(pPopup, label) -> pPopupEntry 6990 """ 6991 6992 _fl_popup_entry_get_by_label = cfuncproto( 6993 load_so_libforms(), "fl_popup_entry_get_by_label", 6994 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_POPUP), STRING], 6995 """FL_POPUP_ENTRY * fl_popup_entry_get_by_label(FL_POPUP * p1, 6996 const char * p2) 6997 """) 6998 slabel = convert_to_string(label) 6999 keep_elem_refs(pPopup, label, slabel) 7000 retval = _fl_popup_entry_get_by_label(pPopup, slabel) 7001 return retval
7002 7003
7004 -def fl_popup_entry_get_group(pPopupEntry):
7005 """ fl_popup_entry_get_group(pPopupEntry) -> num. 7006 """ 7007 7008 _fl_popup_entry_get_group = cfuncproto( 7009 load_so_libforms(), "fl_popup_entry_get_group", 7010 cty.c_int, [cty.POINTER(FL_POPUP_ENTRY)], 7011 """int fl_popup_entry_get_group(FL_POPUP_ENTRY * p1) 7012 """) 7013 keep_elem_refs(pPopupEntry) 7014 retval = _fl_popup_entry_get_group(pPopupEntry) 7015 return retval
7016 7017
7018 -def fl_popup_entry_set_group(pPopupEntry, num):
7019 """ fl_popup_entry_set_group(pPopupEntry, num) -> num. 7020 """ 7021 7022 _fl_popup_entry_set_group = cfuncproto( 7023 load_so_libforms(), "fl_popup_entry_set_group", 7024 cty.c_int, [cty.POINTER(FL_POPUP_ENTRY), cty.c_int], 7025 """int fl_popup_entry_set_group(FL_POPUP_ENTRY * p1, int p2) 7026 """) 7027 inum = convert_to_int(num) 7028 keep_elem_refs(pPopupEntry, num, inum) 7029 retval = _fl_popup_entry_set_group(pPopupEntry, inum) 7030 return retval
7031 7032
7033 -def fl_popup_entry_get_subpopup(pPopupEntry):
7034 """ fl_popup_entry_get_subpopup(pPopupEntry) -> pPopup 7035 """ 7036 7037 _fl_popup_entry_get_subpopup = cfuncproto( 7038 load_so_libforms(), "fl_popup_entry_get_subpopup", 7039 cty.POINTER(FL_POPUP), [cty.POINTER(FL_POPUP_ENTRY)], 7040 """FL_POPUP * fl_popup_entry_get_subpopup(FL_POPUP_ENTRY * p1) 7041 """) 7042 keep_elem_refs(pPopupEntry) 7043 retval = _fl_popup_entry_get_subpopup(pPopupEntry) 7044 return retval
7045 7046
7047 -def fl_popup_entry_set_subpopup(pPopupEntry, pPopup):
7048 """ fl_popup_entry_set_subpopup(pPopupEntry, pPopup) -> pPopup 7049 """ 7050 7051 _fl_popup_entry_set_subpopup = cfuncproto( 7052 load_so_libforms(), "fl_popup_entry_set_subpopup", 7053 cty.POINTER(FL_POPUP), [cty.POINTER(FL_POPUP_ENTRY), 7054 cty.POINTER(FL_POPUP)], 7055 """FL_POPUP * fl_popup_entry_set_subpopup(FL_POPUP_ENTRY * p1, 7056 FL_POPUP * p2) 7057 """) 7058 keep_elem_refs(pPopupEntry, pPopup) 7059 retval = _fl_popup_entry_set_subpopup(pPopupEntry, pPopup) 7060 return retval
7061 7062 7063 #def fl_popup_get_size(pPopup, w, h) *API change*
7064 -def fl_popup_get_size(pPopup):
7065 """ fl_popup_get_size(pPopup) -> size num., width, height 7066 """ 7067 7068 _fl_popup_get_size = cfuncproto( 7069 load_so_libforms(), "fl_popup_get_size", 7070 cty.c_int, [cty.POINTER(FL_POPUP), cty.POINTER(cty.c_uint), 7071 cty.POINTER(cty.c_uint)], 7072 """int fl_popup_get_size(FL_POPUP * p1, unsigned int * p2, 7073 unsigned int * p3) 7074 """) 7075 w, pw = make_uint_and_pointer() 7076 h, ph = make_uint_and_pointer() 7077 keep_elem_refs(pPopup, w, h, pw, ph) 7078 retval = _fl_popup_get_size(pPopup, pw, ph) 7079 return retval, w, h
7080 7081
7082 -def fl_popup_get_min_width(pPopup):
7083 """ fl_popup_get_min_width(pPopup) -> width num. 7084 """ 7085 7086 _fl_popup_get_min_width = cfuncproto( 7087 load_so_libforms(), "fl_popup_get_min_width", 7088 cty.c_int, [cty.POINTER(FL_POPUP)], 7089 """int fl_popup_get_min_width(FL_POPUP * p1) 7090 """) 7091 keep_elem_refs(pPopup) 7092 retval = _fl_popup_get_min_width(pPopup) 7093 return retval
7094 7095
7096 -def fl_popup_set_min_width(pPopup, minwidth):
7097 """ fl_popup_set_min_width(pPopup, minwidth) -> width num. 7098 """ 7099 7100 _fl_popup_set_min_width = cfuncproto( 7101 load_so_libforms(), "fl_popup_set_min_width", 7102 cty.c_int, [cty.POINTER(FL_POPUP), cty.c_int], 7103 """int fl_popup_set_min_width(FL_POPUP * p1, int p2) 7104 """) 7105 iminwidth = convert_to_int(minwidth) 7106 keep_elem_refs(pPopup, minwidth, iminwidth) 7107 retval = _fl_popup_set_min_width(pPopup, iminwidth) 7108 return retval
7109 7110 7111 7112 ####################### 7113 # forms.h (bitmap.h) 7114 # Object Class: Bitmap 7115 ####################### 7116 7117 7118 # Routines 7119
7120 -def fl_create_bitmap(bitmaptype, x, y, w, h, label):
7121 """ 7122 fl_create_bitmap(bitmaptype, x, y, w, h, label) -> pObject 7123 7124 Creates a bitmap object. 7125 7126 @param bitmaptype : type of bitmap to create 7127 @param x : horizontal position of bitmap (upper-left corner) 7128 @param y : vertical position of bitmap (upper-left corner) 7129 @param w : width of bitmap in pixels 7130 @param h : height of bitmap in pixels 7131 @param label : text label of bitmap 7132 """ 7133 7134 _fl_create_bitmap = cfuncproto( 7135 load_so_libforms(), "fl_create_bitmap", 7136 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 7137 FL_Coord, STRING], 7138 """FL_OBJECT * fl_create_bitmap(int type, FL_Coord x, FL_Coord y, 7139 FL_Coord w, FL_Coord h, const char * label) 7140 """) 7141 check_admitted_listvalues(bitmaptype, BITMAPTYPE_list) 7142 ibitmaptype = convert_to_int(bitmaptype) 7143 ix = convert_to_FL_Coord(x) 7144 iy = convert_to_FL_Coord(y) 7145 iw = convert_to_FL_Coord(w) 7146 ih = convert_to_FL_Coord(h) 7147 slabel = convert_to_int(label) 7148 keep_elem_refs(bitmaptype, x, y, w, h, label, ibitmaptype, ix, iy, 7149 iw, ih, slabel) 7150 retval = _fl_create_bitmap(ibitmaptype, ix, iy, iw, ih, slabel) 7151 return retval
7152 7153
7154 -def fl_add_bitmap(bitmaptype, x, y, w, h, label):
7155 """ 7156 fl_add_bitmap(bitmaptype, x, y, w, h, label) -> pObject 7157 7158 Adds a bitmap object. 7159 7160 @param bitmaptype : type of bitmap to be added 7161 @param x : horizontal position of bitmap (upper-left corner) 7162 @param y : vertical position of bitmap (upper-left corner) 7163 @param w : width of bitmap in pixels 7164 @param h : height of bitmap in pixels 7165 @param label : text label of bitmap 7166 """ 7167 7168 _fl_add_bitmap = cfuncproto( 7169 load_so_libforms(), "fl_add_bitmap", 7170 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 7171 FL_Coord, STRING], 7172 """FL_OBJECT * fl_add_bitmap(int type, FL_Coord x, FL_Coord y, 7173 FL_Coord w, FL_Coord h, const char * label) 7174 """) 7175 check_admitted_listvalues(bitmaptype, BITMAPTYPE_list) 7176 ibitmaptype = convert_to_int(bitmaptype) 7177 ix = convert_to_FL_Coord(x) 7178 iy = convert_to_FL_Coord(y) 7179 iw = convert_to_FL_Coord(w) 7180 ih = convert_to_FL_Coord(h) 7181 slabel = convert_to_string(label) 7182 keep_elem_refs(bitmaptype, x, y, w, h, label, ibitmaptype, ix, iy, iw, 7183 ih, slabel) 7184 retval = _fl_add_bitmap(ibitmaptype, ix, iy, iw, ih, slabel) 7185 return retval
7186 7187
7188 -def fl_set_bitmap_data(pObject, w, h, xbmcontents):
7189 """ fl_set_bitmap_data(pObject, w, h, xbmcontents) 7190 7191 Fills the bitmap with a bitmap. 7192 7193 @param pObject : pointer to object 7194 @param w : width of bitmap in pixels 7195 @param h : height of bitmap in pixels 7196 @param xbmcontents : bitmap data used for contents in ubytes 7197 """ 7198 7199 _fl_set_bitmap_data = cfuncproto( 7200 load_so_libforms(), "fl_set_bitmap_data", 7201 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int, 7202 cty.POINTER(cty.c_ubyte)], 7203 """void fl_set_bitmap_data(FL_OBJECT * ob, int w, int h, 7204 unsigned char * data) 7205 """) 7206 iw = convert_to_int(w) 7207 ih = convert_to_int(h) 7208 pxbmcontents = cty.cast(xbmcontents, cty.POINTER(cty.c_ubyte)) 7209 keep_elem_refs(pObject, w, h, xbmcontents, iw, ih, pxbmcontents) 7210 _fl_set_bitmap_data(pObject, iw, ih, pxbmcontents)
7211 7212
7213 -def fl_set_bitmap_file(pObject, fname):
7214 """ fl_set_bitmap_file(pObject, fname) 7215 7216 @param pObject : pointer to object 7217 @param fname : name of bitmap file 7218 """ 7219 7220 _fl_set_bitmap_file = cfuncproto( 7221 load_so_libforms(), "fl_set_bitmap_file", 7222 None, [cty.POINTER(FL_OBJECT), STRING], 7223 """void fl_set_bitmap_file(FL_OBJECT * ob, const char * fname) 7224 """) 7225 sfname = convert_to_string(fname) 7226 keep_elem_refs(pObject, fname, sfname) 7227 _fl_set_bitmap_file(pObject, sfname)
7228 7229
7230 -def fl_read_bitmapfile(win, filename, w, h, hotx, hoty):
7231 """ fl_read_bitmapfile(win, filename, w, h, hotx, hoty) -> pixmap 7232 """ 7233 7234 _fl_read_bitmapfile = cfuncproto( 7235 load_so_libforms(), "fl_read_bitmapfile", 7236 Pixmap, [Window, STRING, cty.POINTER(cty.c_uint), 7237 cty.POINTER(cty.c_uint), cty.POINTER(cty.c_int), 7238 cty.POINTER(cty.c_int)], 7239 """Pixmap fl_read_bitmapfile(Window win, const char * file, 7240 unsigned int * w, unsigned int * h, int * hotx, int * hoty) 7241 """) 7242 ulwin = convert_to_Window(win) 7243 sfilename = convert_to_string(filename) 7244 pw = cty.cast(w, cty.POINTER(cty.c_uint)) 7245 ph = cty.cast(h, cty.POINTER(cty.c_uint)) 7246 photx = cty.cast(hotx, cty.POINTER(cty.c_int)) 7247 photy = cty.cast(hoty, cty.POINTER(cty.c_int)) 7248 keep_elem_refs(win, filename, w, h, hotx, hoty, ulwin, sfilename, 7249 pw, ph, photx, photy) 7250 retval = _fl_read_bitmapfile(ulwin, sfilename, pw, ph, photx, photy) 7251 return retval
7252 7253
7254 -def fl_create_from_bitmapdata(win, data, w, h):
7255 """ 7256 fl_create_from_bitmapdata(win, data, w, h) -> pixmap 7257 7258 @param win : window 7259 @param data : bitmap data 7260 @param w : width of bitmap in pixels 7261 @param h : height of bitmap in pixels 7262 """ 7263 7264 _fl_create_from_bitmapdata = cfuncproto( 7265 load_so_libforms(), "fl_create_from_bitmapdata", 7266 Pixmap, [Window, STRING, cty.c_int, cty.c_int], 7267 """Pixmap fl_create_from_bitmapdata(Window win, const 7268 char * data, int width, int height) 7269 """) 7270 ulwin = convert_to_ulong(win) 7271 sdata = convert_to_string(data) 7272 iw = convert_to_int(w) 7273 ih = convert_to_int(h) 7274 keep_elem_refs(win, data, w, h, ulwin, sdata, iw, ih) 7275 retval = _fl_create_from_bitmapdata(ulwin, sdata, iw, ih) 7276 return retval
7277 7278 7279 # for compatibility 7280 fl_set_bitmap_datafile = fl_set_bitmap_file 7281 7282 7283 # PIXMAP stuff 7284
7285 -def fl_create_pixmap(pixmaptype, x, y, w, h, label):
7286 """ fl_create_pixmap(pixmaptype, x, y, w, h, label) -> pObject 7287 """ 7288 7289 _fl_create_pixmap = cfuncproto( 7290 load_so_libforms(), "fl_create_pixmap", 7291 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 7292 FL_Coord, STRING], 7293 """FL_OBJECT * fl_create_pixmap(int type, FL_Coord x, FL_Coord y, 7294 FL_Coord w, FL_Coord h, const char * label) 7295 """) 7296 check_admitted_listvalues(pixmaptype, PIXMAPTYPE_list) 7297 ipixmaptype = convert_to_int(pixmaptype) 7298 ix = convert_to_FL_Coord(x) 7299 iy = convert_to_FL_Coord(y) 7300 iw = convert_to_FL_Coord(w) 7301 ih = convert_to_FL_Coord(h) 7302 slabel = convert_to_string(label) 7303 keep_elem_refs(pixmaptype, x, y, w, h, label, ipixmaptype, ix, iy, iw, 7304 ih, slabel) 7305 retval = _fl_create_pixmap(ipixmaptype, ix, iy, iw, ih, slabel) 7306 return retval
7307 7308
7309 -def fl_add_pixmap(pixmaptype, x, y, w, h, label):
7310 """ fl_add_pixmap(pixmaptype, x, y, w, h, label) -> pObject 7311 """ 7312 7313 _fl_add_pixmap = cfuncproto( 7314 load_so_libforms(), "fl_add_pixmap", 7315 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 7316 FL_Coord, STRING], 7317 """FL_OBJECT * fl_add_pixmap(int type, FL_Coord x, FL_Coord y, 7318 FL_Coord w, FL_Coord h, const char * label) 7319 """) 7320 check_admitted_listvalues(pixmaptype, PIXMAPTYPE_list) 7321 ipixmaptype = convert_to_int(pixmaptype) 7322 ix = convert_to_FL_Coord(x) 7323 iy = convert_to_FL_Coord(y) 7324 iw = convert_to_FL_Coord(w) 7325 ih = convert_to_FL_Coord(h) 7326 slabel = convert_to_string(label) 7327 keep_elem_refs(pixmaptype, x, y, w, h, label, ipixmaptype, ix, iy, iw, 7328 ih, slabel) 7329 retval = _fl_add_pixmap(ipixmaptype, ix, iy, iw, ih, slabel) 7330 return retval
7331 7332
7333 -def fl_set_pixmap_data(pObject, bits):
7334 """ fl_set_pixmap_data(pObject, bits) 7335 """ 7336 7337 _fl_set_pixmap_data = cfuncproto( 7338 load_so_libforms(), "fl_set_pixmap_data", 7339 None, [cty.POINTER(FL_OBJECT), cty.POINTER(STRING)], 7340 """void fl_set_pixmap_data(FL_OBJECT * ob, char * * bits) 7341 """) 7342 keep_elem_refs(pObject, bits) 7343 _fl_set_pixmap_data(pObject, bits)
7344 7345
7346 -def fl_set_pixmap_file(pObject, fname):
7347 """ fl_set_pixmap_file(pObject, fname) 7348 7349 @param pObject : pointer to object 7350 @param fname : name of the pixmap file 7351 """ 7352 7353 _fl_set_pixmap_file = cfuncproto( 7354 load_so_libforms(), "fl_set_pixmap_file", 7355 None, [cty.POINTER(FL_OBJECT), STRING], 7356 """void fl_set_pixmap_file(FL_OBJECT * ob, const char * fname) 7357 """) 7358 sfname = convert_to_string(fname) 7359 keep_elem_refs(pObject, fname, sfname) 7360 _fl_set_pixmap_file(pObject, sfname)
7361 7362
7363 -def fl_set_pixmap_align(pObject, align, xmargin, ymargin):
7364 """ fl_set_pixmap_align(pObject, align, xmargin, ymargin) 7365 """ 7366 7367 _fl_set_pixmap_align = cfuncproto( 7368 load_so_libforms(), "fl_set_pixmap_align", 7369 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int, cty.c_int], 7370 """void fl_set_pixmap_align(FL_OBJECT * ob, int align, 7371 int xmargin, int ymargin) 7372 """) 7373 check_admitted_listvalues(align, ALIGN_list) 7374 ialign = convert_to_int(align) 7375 ixmargin = convert_to_int(xmargin) 7376 iymargin = convert_to_int(ymargin) 7377 keep_elem_refs(pObject, align, xmargin, ymargin, ialign, ixmargin, 7378 iymargin) 7379 _fl_set_pixmap_align(pObject, ialign, ixmargin, iymargin)
7380 7381
7382 -def fl_set_pixmap_pixmap(pObject, idnum, mask):
7383 """ fl_set_pixmap_pixmap(pObject, idnum, mask) 7384 """ 7385 7386 _fl_set_pixmap_pixmap = cfuncproto( 7387 load_so_libforms(), "fl_set_pixmap_pixmap", 7388 None, [cty.POINTER(FL_OBJECT), Pixmap, Pixmap], 7389 """void fl_set_pixmap_pixmap(FL_OBJECT * ob, Pixmap id, 7390 Pixmap mask) 7391 """) 7392 ulidnum = convert_to_ulong(idnum) 7393 ulmask = convert_to_ulong(mask) 7394 keep_elem_refs(pObject, idnum, mask, ulidnum, ulmask) 7395 _fl_set_pixmap_pixmap(pObject, ulidnum, ulmask)
7396 7397
7398 -def fl_set_pixmap_colorcloseness(red, green, blue):
7399 """ fl_set_pixmap_colorcloseness(red, green, blue) 7400 """ 7401 7402 _fl_set_pixmap_colorcloseness = cfuncproto( 7403 load_so_libforms(), "fl_set_pixmap_colorcloseness", 7404 None, [cty.c_int, cty.c_int, cty.c_int], 7405 """void fl_set_pixmap_colorcloseness(int red, int green, int blue) 7406 """) 7407 ired = convert_to_int(red) 7408 igreen = convert_to_int(green) 7409 iblue = convert_to_int(blue) 7410 keep_elem_refs(red, green, blue, ired, igreen, iblue) 7411 _fl_set_pixmap_colorcloseness(ired, igreen, iblue)
7412 7413
7414 -def fl_free_pixmap_pixmap(pObject):
7415 """ fl_free_pixmap_pixmap(pObject) 7416 7417 @param pObject : pointer to object 7418 """ 7419 7420 _fl_free_pixmap_pixmap = cfuncproto( 7421 load_so_libforms(), "fl_free_pixmap_pixmap", 7422 None, [cty.POINTER(FL_OBJECT)], 7423 """void fl_free_pixmap_pixmap(FL_OBJECT * ob) 7424 """) 7425 keep_elem_refs(pObject) 7426 _fl_free_pixmap_pixmap(pObject)
7427 7428 7429 #def fl_get_pixmap_pixmap(pObject, p, m) *API change*
7430 -def fl_get_pixmap_pixmap(pObject):
7431 """ fl_get_pixmap_pixmap(pObject) -> pixmap, pPixmap, pPixmap_mask 7432 7433 @param pObject : pointer to object 7434 """ 7435 7436 _fl_get_pixmap_pixmap = cfuncproto( 7437 load_so_libforms(), "fl_get_pixmap_pixmap", 7438 Pixmap, [cty.POINTER(FL_OBJECT), cty.POINTER(Pixmap), 7439 cty.POINTER(Pixmap)], 7440 """Pixmap fl_get_pixmap_pixmap(FL_OBJECT * ob, Pixmap * p, 7441 Pixmap * m) 7442 """) 7443 p, pp = make_ulong_and_pointer() 7444 m, pm = make_ulong_and_pointer() 7445 keep_elem_refs(pObject, p, m, pp, pm) 7446 retval = _fl_get_pixmap_pixmap(pObject, pp, pm) 7447 return retval, p, m
7448 7449 7450 #def fl_read_pixmapfile(win, filename, w, h, shape_mask, hotx, hoty, tran) *API change*
7451 -def fl_read_pixmapfile(win, filename, tran):
7452 """ fl_read_pixmapfile(win, filename, tran) -> pixmap, w, h, shapemask, hotx, hoty 7453 """ 7454 7455 _fl_read_pixmapfile = cfuncproto( 7456 load_so_libforms(), "fl_read_pixmapfile", 7457 Pixmap, [Window, STRING, cty.POINTER(cty.c_uint), 7458 cty.POINTER(cty.c_uint), cty.POINTER(Pixmap), 7459 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), FL_COLOR], 7460 """Pixmap fl_read_pixmapfile(Window win, const char * file, 7461 unsigned int * w, unsigned int * h, Pixmap * shape_mask, 7462 int * hotx, int * hoty, FL_COLOR tran) 7463 """) 7464 check_admitted_listvalues(tran, COLOR_list) 7465 ulwin = convert_to_Window(win) 7466 sfilename = convert_to_string(filename) 7467 ultran = convert_to_FL_COLOR(tran) 7468 w, pw = make_uint_and_pointer() 7469 h, ph = make_uint_and_pointer() 7470 shapemask, pshapemask = make_ulong_and_pointer() 7471 hotx, photx = make_int_and_pointer() 7472 hoty, photy = make_int_and_pointer() 7473 keep_elem_refs(win, filename, w, h, shapemask, hotx, hoty, tran, ulwin, 7474 sfilename, ultran, pw, ph, pshapemask, photx, photy) 7475 retval = _fl_read_pixmapfile(ulwin, sfilename, pw, ph, pshapemask, \ 7476 photx, photy, ultran) 7477 return retval, w, h, shapemask, hotx, hoty
7478 7479
7480 -def fl_create_from_pixmapdata(win, data, w, h, sm, hotx, hoty, tran):
7481 """ fl_create_from_pixmapdata(win, data, w, h, sm, hotx, hoty, tran) -> pixmap 7482 """ 7483 7484 _fl_create_from_pixmapdata = cfuncproto( 7485 load_so_libforms(), "fl_create_from_pixmapdata", 7486 Pixmap, [Window, cty.POINTER(STRING), cty.POINTER(cty.c_uint), 7487 cty.POINTER(cty.c_uint), cty.POINTER(Pixmap), 7488 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), FL_COLOR], 7489 """Pixmap fl_create_from_pixmapdata(Window win, char * * data, 7490 unsigned int * w, unsigned int * h, Pixmap * sm, int * hotx, 7491 int * hoty, FL_COLOR tran) 7492 """) 7493 check_admitted_listvalues(tran, COLOR_list) 7494 ulwin = convert_to_Window(win) 7495 ultran = convert_to_FL_COLOR(tran) 7496 keep_elem_refs(win, data, w, h, sm, hotx, hoty, tran, ulwin, ultran) 7497 retval = _fl_create_from_pixmapdata(ulwin, data, w, h, sm, hotx, hoty, 7498 ultran) 7499 return retval
7500 7501
7502 -def fl_free_pixmap(idnum):
7503 """ fl_free_pixmap(idnum) 7504 7505 @param idnum : Pixmap id to be freed 7506 """ 7507 7508 _fl_free_pixmap = cfuncproto( 7509 load_so_libforms(), "fl_free_pixmap", 7510 None, [Pixmap], 7511 """void fl_free_pixmap(Pixmap id) 7512 """) 7513 ulidnum = convert_to_Pixmap(idnum) 7514 keep_elem_refs(idnum, ulidnum) 7515 _fl_free_pixmap(ulidnum)
7516 7517 7518 ################## 7519 # forms.h (box.h) 7520 ################## 7521
7522 -def fl_create_box(boxtype, x, y, w, h, label):
7523 """ 7524 fl_create_box(boxtype, x, y, w, h, label) -> pObject 7525 7526 Creates a box object. 7527 7528 @param boxtype : type of the box to be created 7529 @param x : horizontal position of box (upper-left corner) 7530 @param y : vertical position of box (upper-left corner) 7531 @param w : width of box in pixel 7532 @param h : height of box in pixel 7533 @param label : text label of box 7534 """ 7535 7536 _fl_create_box = cfuncproto( 7537 load_so_libforms(), "fl_create_box", 7538 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 7539 FL_Coord, STRING], 7540 """FL_OBJECT * fl_create_box(int type, FL_Coord x, FL_Coord y, 7541 FL_Coord w, FL_Coord h, const char * label) 7542 """) 7543 check_admitted_listvalues(boxtype, BOXTYPE_list) 7544 iboxtype = convert_to_int(boxtype) 7545 ix = convert_to_FL_Coord(x) 7546 iy = convert_to_FL_Coord(y) 7547 iw = convert_to_FL_Coord(w) 7548 ih = convert_to_FL_Coord(h) 7549 slabel = convert_to_string(label) 7550 keep_elem_refs(boxtype, x, y, w, h, label, iboxtype, ix, iy, iw, 7551 ih, slabel) 7552 retval = _fl_create_box(iboxtype, ix, iy, iw, ih, slabel) 7553 return retval
7554 7555
7556 -def fl_add_box(boxtype, x, y, w, h, label):
7557 """ 7558 fl_add_box(boxtype, x, y, w, h, label) -> pObject 7559 7560 Adds a box object. 7561 7562 @param boxtype : type of the box to be added 7563 @param x : horizontal position of box (upper-left corner) 7564 @param y : vertical position of box (upper-left corner) 7565 @param w : width of box in pixel 7566 @param h : height of box in pixel 7567 @param label : text label of box 7568 """ 7569 7570 _fl_add_box = cfuncproto( 7571 load_so_libforms(), "fl_add_box", 7572 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 7573 FL_Coord, STRING], 7574 """FL_OBJECT * fl_add_box(int type, FL_Coord x, FL_Coord y, 7575 FL_Coord w, FL_Coord h, const char * label) 7576 """) 7577 check_admitted_listvalues(boxtype, BOXTYPE_list) 7578 iboxtype = convert_to_int(boxtype) 7579 ix = convert_to_FL_Coord(x) 7580 iy = convert_to_FL_Coord(y) 7581 iw = convert_to_FL_Coord(w) 7582 ih = convert_to_FL_Coord(h) 7583 slabel = convert_to_string(label) 7584 keep_elem_refs(boxtype, x, y, w, h, label, iboxtype, ix, iy, iw, 7585 ih, slabel) 7586 retval = _fl_add_box(iboxtype, ix, iy, iw, ih, slabel) 7587 return retval
7588 7589 7590 7591 ####################### 7592 # forms.h (browser.h) 7593 # Object class Browser 7594 ####################### 7595 7596 # Routines 7597
7598 -def fl_create_browser(browsertype, x, y, w, h, label):
7599 """ 7600 fl_create_browser(browsertype, x, y, w, h, label) -> pObject 7601 7602 Creates a browser object. 7603 7604 @param browsertype : type of the browser to be created 7605 @param x : horizontal position of browser (upper-left corner) 7606 @param y : vertical position of browser (upper-left corner) 7607 @param w : width of browser in pixel 7608 @param h : height of browser in pixel 7609 @param label : text label of browser 7610 """ 7611 7612 _fl_create_browser = cfuncproto( 7613 load_so_libforms(), "fl_create_browser", 7614 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 7615 FL_Coord, STRING], 7616 """FL_OBJECT * fl_create_browser(int type, FL_Coord x, FL_Coord y, 7617 FL_Coord w, FL_Coord h, const char * label) 7618 """) 7619 check_admitted_listvalues(browsertype, BROWSERTYPE_list) 7620 ibrowsertype = convert_to_int(browsertype) 7621 ix = convert_to_FL_Coord(x) 7622 iy = convert_to_FL_Coord(y) 7623 iw = convert_to_FL_Coord(w) 7624 ih = convert_to_FL_Coord(h) 7625 slabel = convert_to_string(label) 7626 keep_elem_refs(browsertype, x, y, w, h, label, ibrowsertype, ix, iy, iw, 7627 ih, slabel) 7628 retval = _fl_create_browser(ibrowsertype, ix, iy, iw, ih, slabel) 7629 return retval
7630 7631
7632 -def fl_add_browser(browsertype, x, y, w, h, label):
7633 """ 7634 fl_add_browser(browsertype, x, y, w, h, label) -> pObject 7635 7636 Adds a browser object. 7637 7638 @param browsertype : type of the browser to be added 7639 @param x : horizontal position of browser (upper-left corner) 7640 @param y : vertical position of browser (upper-left corner) 7641 @param w : width of browser in pixels 7642 @param h : height of browser in pixels 7643 @param label : text label of browser 7644 """ 7645 7646 _fl_add_browser = cfuncproto( 7647 load_so_libforms(), "fl_add_browser", 7648 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 7649 FL_Coord, STRING], 7650 """FL_OBJECT * fl_add_browser(int type, FL_Coord x, FL_Coord y, 7651 FL_Coord w, FL_Coord h, const char * label) 7652 """) 7653 check_admitted_listvalues(browsertype, BROWSERTYPE_list) 7654 ibrowsertype = convert_to_int(browsertype) 7655 ix = convert_to_FL_Coord(x) 7656 iy = convert_to_FL_Coord(y) 7657 iw = convert_to_FL_Coord(w) 7658 ih = convert_to_FL_Coord(h) 7659 slabel = convert_to_string(label) 7660 keep_elem_refs(browsertype, x, y, w, h, label, ibrowsertype, ix, iy, iw, 7661 ih, slabel) 7662 retval = _fl_add_browser(ibrowsertype, ix, iy, iw, ih, slabel) 7663 return retval
7664 7665
7666 -def fl_clear_browser(pObject):
7667 """ 7668 fl_clear_browser(pObject) 7669 7670 Clears browser object's contents. 7671 7672 @param pObject : poiter to browser object 7673 """ 7674 7675 _fl_clear_browser = cfuncproto( 7676 load_so_libforms(), "fl_clear_browser", 7677 None, [cty.POINTER(FL_OBJECT)], 7678 """void fl_clear_browser(FL_OBJECT * ob) 7679 """) 7680 keep_elem_refs(pObject) 7681 _fl_clear_browser(pObject)
7682 7683
7684 -def fl_add_browser_line(pObject, newtext):
7685 """ 7686 fl_add_browser_line(pObject, newtext) 7687 7688 Add a line to a browser object. 7689 7690 @param pObject : pointer to browser object 7691 @param newtext : line of text to be added 7692 """ 7693 7694 _fl_add_browser_line = cfuncproto( 7695 load_so_libforms(), "fl_add_browser_line", 7696 None, [cty.POINTER(FL_OBJECT), STRING], 7697 """void fl_add_browser_line(FL_OBJECT * ob, const char * newtext) 7698 """) 7699 snewtext = convert_to_string(newtext) 7700 keep_elem_refs(pObject, newtext, snewtext) 7701 _fl_add_browser_line(pObject, snewtext)
7702 7703
7704 -def fl_addto_browser(pObject, newtext):
7705 """ fl_addto_browser(pObject, newtext) 7706 """ 7707 7708 _fl_addto_browser = cfuncproto( 7709 load_so_libforms(), "fl_addto_browser", 7710 None, [cty.POINTER(FL_OBJECT), STRING], 7711 """void fl_addto_browser(FL_OBJECT * ob, const char * newtext) 7712 """) 7713 snewtext = convert_to_string(newtext) 7714 keep_elem_refs(pObject, newtext, snewtext) 7715 _fl_addto_browser(pObject, snewtext)
7716 7717
7718 -def fl_addto_browser_chars(pObject, browsertext):
7719 """ fl_addto_browser_chars(pObject, browsertext) 7720 """ 7721 7722 _fl_addto_browser_chars = cfuncproto( 7723 load_so_libforms(), "fl_addto_browser_chars", 7724 None, [cty.POINTER(FL_OBJECT), STRING], 7725 """void fl_addto_browser_chars(FL_OBJECT * ob, const char * str) 7726 """) 7727 sbrowsertext = convert_to_string(browsertext) 7728 keep_elem_refs(pObject, browsertext, sbrowsertext) 7729 _fl_addto_browser_chars(pObject, sbrowsertext)
7730 7731 7732 fl_append_browser = fl_addto_browser_chars 7733 7734
7735 -def fl_insert_browser_line(pObject, linenumb, newtext):
7736 """ fl_insert_browser_line(pObject, linenumb, newtext) 7737 """ 7738 7739 _fl_insert_browser_line = cfuncproto( 7740 load_so_libforms(), "fl_insert_browser_line", 7741 None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 7742 """void fl_insert_browser_line(FL_OBJECT * ob, int linenumb, 7743 const char * newtext) 7744 """) 7745 ilinenumb = convert_to_int(linenumb) 7746 snewtext = convert_to_string(newtext) 7747 keep_elem_refs(pObject, linenumb, newtext, ilinenumb, snewtext) 7748 _fl_insert_browser_line(pObject, ilinenumb, snewtext)
7749 7750
7751 -def fl_delete_browser_line(pObject, linenumb):
7752 """ fl_delete_browser_line(pObject, linenumb) 7753 """ 7754 7755 _fl_delete_browser_line = cfuncproto( 7756 load_so_libforms(), "fl_delete_browser_line", 7757 None, [cty.POINTER(FL_OBJECT), cty.c_int], 7758 """void fl_delete_browser_line(FL_OBJECT * ob, int linenumb) 7759 """) 7760 ilinenumb = convert_to_int(linenumb) 7761 keep_elem_refs(pObject, linenumb, ilinenumb) 7762 _fl_delete_browser_line(pObject, ilinenumb)
7763 7764
7765 -def fl_replace_browser_line(pObject, linenumb, newtext):
7766 """ fl_replace_browser_line(pObject, linenumb, newtext) 7767 """ 7768 7769 _fl_replace_browser_line = cfuncproto( 7770 load_so_libforms(), "fl_replace_browser_line", 7771 None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 7772 """void fl_replace_browser_line(FL_OBJECT * ob, int linenumb, 7773 const char * newtext) 7774 """) 7775 ilinenumb = convert_to_int(linenumb) 7776 snewtext = convert_to_string(newtext) 7777 keep_elem_refs(pObject, linenumb, newtext, ilinenumb, snewtext) 7778 _fl_replace_browser_line(pObject, ilinenumb, snewtext)
7779 7780
7781 -def fl_get_browser_line(pObject, linenumb):
7782 """ fl_get_browser_line(pObject, linenumb) -> line string 7783 """ 7784 7785 _fl_get_browser_line = cfuncproto( 7786 load_so_libforms(), "fl_get_browser_line", 7787 STRING, [cty.POINTER(FL_OBJECT), cty.c_int], 7788 """const char * fl_get_browser_line(FL_OBJECT * ob, int linenumb) 7789 """) 7790 ilinenumb = convert_to_int(linenumb) 7791 keep_elem_refs(pObject, linenumb, ilinenumb) 7792 retval = _fl_get_browser_line(pObject, ilinenumb) 7793 return retval
7794 7795
7796 -def fl_load_browser(pObject, filename):
7797 """ fl_load_browser(pObject, filename) -> num. 7798 """ 7799 7800 _fl_load_browser = cfuncproto( 7801 load_so_libforms(), "fl_load_browser", 7802 cty.c_int, [cty.POINTER(FL_OBJECT), STRING], 7803 """int fl_load_browser(FL_OBJECT * ob, const char * filename) 7804 """) 7805 sfilename = convert_to_string(filename) 7806 keep_elem_refs(pObject, filename, sfilename) 7807 retval = _fl_load_browser(pObject, sfilename) 7808 return retval
7809 7810
7811 -def fl_select_browser_line(pObject, line):
7812 """ fl_select_browser_line(pObject, line) 7813 """ 7814 7815 _fl_select_browser_line = cfuncproto( 7816 load_so_libforms(), "fl_select_browser_line", 7817 None, [cty.POINTER(FL_OBJECT), cty.c_int], 7818 """void fl_select_browser_line(FL_OBJECT * ob, int line) 7819 """) 7820 iline = convert_to_int(line) 7821 keep_elem_refs(pObject, line, iline) 7822 _fl_select_browser_line(pObject, iline)
7823 7824
7825 -def fl_deselect_browser_line(pObject, line):
7826 """ fl_deselect_browser_line(pObject, line) 7827 """ 7828 7829 _fl_deselect_browser_line = cfuncproto( 7830 load_so_libforms(), "fl_deselect_browser_line", 7831 None, [cty.POINTER(FL_OBJECT), cty.c_int], 7832 """void fl_deselect_browser_line(FL_OBJECT * ob, int line) 7833 """) 7834 iline = convert_to_int(line) 7835 keep_elem_refs(pObject, line, iline) 7836 _fl_deselect_browser_line(pObject, iline)
7837 7838
7839 -def fl_deselect_browser(pObject):
7840 """ fl_deselect_browser(pObject) 7841 7842 @param pObject : pointer to object 7843 """ 7844 7845 _fl_deselect_browser = cfuncproto( 7846 load_so_libforms(), "fl_deselect_browser", 7847 None, [cty.POINTER(FL_OBJECT)], 7848 """void fl_deselect_browser(FL_OBJECT * ob) 7849 """) 7850 keep_elem_refs(pObject) 7851 _fl_deselect_browser(pObject)
7852 7853
7854 -def fl_isselected_browser_line(pObject, line):
7855 """ fl_isselected_browser_line(pObject, line) -> num. 7856 """ 7857 7858 _fl_isselected_browser_line = cfuncproto( 7859 load_so_libforms(), "fl_isselected_browser_line", 7860 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 7861 """int fl_isselected_browser_line(FL_OBJECT * ob, int line) 7862 """) 7863 iline = convert_to_int(line) 7864 keep_elem_refs(pObject, line, iline) 7865 retval = _fl_isselected_browser_line(pObject, iline) 7866 return retval
7867 7868
7869 -def fl_get_browser_topline(pObject):
7870 """ fl_get_browser_topline(pObject) -> num. 7871 """ 7872 7873 _fl_get_browser_topline = cfuncproto( 7874 load_so_libforms(), "fl_get_browser_topline", 7875 cty.c_int, [cty.POINTER(FL_OBJECT)], 7876 """int fl_get_browser_topline(FL_OBJECT * ob) 7877 """) 7878 keep_elem_refs(pObject) 7879 retval = _fl_get_browser_topline(pObject) 7880 return retval
7881 7882
7883 -def fl_get_browser(pObject):
7884 """ fl_get_browser(pObject) -> num. 7885 """ 7886 7887 _fl_get_browser = cfuncproto( 7888 load_so_libforms(), "fl_get_browser", 7889 cty.c_int, [cty.POINTER(FL_OBJECT)], 7890 """int fl_get_browser(FL_OBJECT * ob) 7891 """) 7892 keep_elem_refs(pObject) 7893 retval = _fl_get_browser(pObject) 7894 return retval
7895 7896
7897 -def fl_get_browser_maxline(pObject):
7898 """ fl_get_browser_maxline(pObject) -> line num. 7899 """ 7900 7901 _fl_get_browser_maxline = cfuncproto( 7902 load_so_libforms(), "fl_get_browser_maxline", 7903 cty.c_int, [cty.POINTER(FL_OBJECT)], 7904 """int fl_get_browser_maxline(FL_OBJECT * ob) 7905 """) 7906 keep_elem_refs(pObject) 7907 retval = _fl_get_browser_maxline(pObject) 7908 return retval
7909 7910
7911 -def fl_get_browser_screenlines(pObject):
7912 """ 7913 fl_get_browser_screenlines(pObject) -> lines num. 7914 7915 Returns an approximation of the number of lines shown in the 7916 browser. 7917 7918 @param pObject : pointer to browser object 7919 """ 7920 7921 _fl_get_browser_screenlines = cfuncproto( 7922 load_so_libforms(), "fl_get_browser_screenlines", 7923 cty.c_int, [cty.POINTER(FL_OBJECT)], 7924 """int fl_get_browser_screenlines(FL_OBJECT * ob) 7925 """) 7926 keep_elem_refs(pObject) 7927 retval = _fl_get_browser_screenlines(pObject) 7928 return retval
7929 7930
7931 -def fl_set_browser_topline(pObject, line):
7932 """ 7933 fl_set_browser_topline(pObject, line) 7934 7935 Moves a line to the top of the browser. 7936 7937 @param pObject : pointer to browser object 7938 @param line : number of text line to be moved to top 7939 """ 7940 7941 _fl_set_browser_topline = cfuncproto( 7942 load_so_libforms(), "fl_set_browser_topline", 7943 None, [cty.POINTER(FL_OBJECT), cty.c_int], 7944 """void fl_set_browser_topline(FL_OBJECT * ob, int line) 7945 """) 7946 iline = convert_to_int(line) 7947 keep_elem_refs(pObject, line, iline) 7948 _fl_set_browser_topline(pObject, iline)
7949 7950
7951 -def fl_set_browser_bottomline(pObject, line):
7952 """ 7953 fl_set_browser_bottomline(pObject, line) 7954 7955 Moves a line to the bottom of the browser. 7956 7957 @param pObject : pointer to browser object 7958 @param line : number of text line to be moved to bottom 7959 """ 7960 7961 _fl_set_browser_bottomline = cfuncproto( 7962 load_so_libforms(), "fl_set_browser_bottomline", 7963 None, [cty.POINTER(FL_OBJECT), cty.c_int], 7964 """void fl_set_browser_bottomline(FL_OBJECT * ob, int line) 7965 """) 7966 iline = convert_to_int(line) 7967 keep_elem_refs(pObject, line, iline) 7968 _fl_set_browser_bottomline(pObject, iline)
7969 7970
7971 -def fl_set_browser_fontsize(pObject, size):
7972 """ 7973 fl_set_browser_fontsize(pObject, size) 7974 7975 Sets the font size of a browser object. 7976 7977 @param pObject : pointer to browser object 7978 @param size : font size to be set 7979 """ 7980 7981 _fl_set_browser_fontsize = cfuncproto( 7982 load_so_libforms(), "fl_set_browser_fontsize", 7983 None, [cty.POINTER(FL_OBJECT), cty.c_int], 7984 """void fl_set_browser_fontsize(FL_OBJECT * ob, int size) 7985 """) 7986 isize = convert_to_int(size) 7987 keep_elem_refs(pObject, size, isize) 7988 _fl_set_browser_fontsize(pObject, isize)
7989 7990
7991 -def fl_set_browser_fontstyle(pObject, style):
7992 """ 7993 fl_set_browser_fontstyle(pObject, style) 7994 7995 Sets the font style of a browser object. 7996 7997 @param pObject : pointer to browser object 7998 @param style : font style to be set 7999 """ 8000 8001 _fl_set_browser_fontstyle = cfuncproto( 8002 load_so_libforms(), "fl_set_browser_fontstyle", 8003 None, [cty.POINTER(FL_OBJECT), cty.c_int], 8004 """void fl_set_browser_fontstyle(FL_OBJECT * ob, int style) 8005 """) 8006 istyle = convert_to_int(style) 8007 keep_elem_refs(pObject, style, istyle) 8008 _fl_set_browser_fontstyle(pObject, istyle)
8009 8010
8011 -def fl_set_browser_specialkey(pObject, specialkey):
8012 """ 8013 fl_set_browser_specialkey(pObject, specialkey) 8014 8015 Sets the escape key used in the text. 8016 8017 @param pObject : pointer to browser object 8018 @param specialkey : escape key to be set 8019 """ 8020 8021 _fl_set_browser_specialkey = cfuncproto( 8022 load_so_libforms(), "fl_set_browser_specialkey", 8023 None, [cty.POINTER(FL_OBJECT), cty.c_int], 8024 """void fl_set_browser_specialkey(FL_OBJECT * ob, int specialkey) 8025 """) 8026 ispecialkey = convert_to_int(specialkey) 8027 keep_elem_refs(pObject, specialkey, ispecialkey) 8028 _fl_set_browser_specialkey(pObject, ispecialkey)
8029 8030
8031 -def fl_set_browser_vscrollbar(pObject, on):
8032 """ fl_set_browser_vscrollbar(pObject, on) 8033 """ 8034 8035 _fl_set_browser_vscrollbar = cfuncproto( 8036 load_so_libforms(), "fl_set_browser_vscrollbar", 8037 None, [cty.POINTER(FL_OBJECT), cty.c_int], 8038 """void fl_set_browser_vscrollbar(FL_OBJECT * ob, int on) 8039 """) 8040 ion = convert_to_int(on) 8041 keep_elem_refs(pObject, on, ion) 8042 _fl_set_browser_vscrollbar(pObject, ion)
8043 8044
8045 -def fl_set_browser_hscrollbar(pObject, on):
8046 """ fl_set_browser_hscrollbar(pObject, on) 8047 """ 8048 8049 _fl_set_browser_hscrollbar = cfuncproto( 8050 load_so_libforms(), "fl_set_browser_hscrollbar", 8051 None, [cty.POINTER(FL_OBJECT), cty.c_int], 8052 """void fl_set_browser_hscrollbar(FL_OBJECT * ob, int on) 8053 """) 8054 ion = convert_to_int(on) 8055 keep_elem_refs(pObject, on, ion) 8056 _fl_set_browser_hscrollbar(pObject, ion)
8057 8058
8059 -def fl_set_browser_line_selectable(pObject, line, flag):
8060 """ fl_set_browser_line_selectable(pObject, line, flag) 8061 """ 8062 8063 _fl_set_browser_line_selectable = cfuncproto( 8064 load_so_libforms(), "fl_set_browser_line_selectable", 8065 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 8066 """void fl_set_browser_line_selectable(FL_OBJECT * ob, int line, 8067 int flag) 8068 """) 8069 iline = convert_to_int(line) 8070 iflag = convert_to_int(flag) 8071 keep_elem_refs(pObject, line, flag, iline, iflag) 8072 _fl_set_browser_line_selectable(pObject, iline, iflag)
8073 8074 8075 #def fl_get_browser_dimension(pObject, x, y, w, h) *API change*
8076 -def fl_get_browser_dimension(pObject):
8077 """ 8078 fl_get_browser_dimension(pObject) -> hor.xpos, ver.ypos, width, height 8079 8080 Returns all dimensions of a browser object. 8081 8082 @param pObject : pointer to browser object 8083 """ 8084 8085 _fl_get_browser_dimension = cfuncproto( 8086 load_so_libforms(), "fl_get_browser_dimension", 8087 None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_Coord), 8088 cty.POINTER(FL_Coord), cty.POINTER(FL_Coord), 8089 cty.POINTER(FL_Coord)], 8090 """void fl_get_browser_dimension(FL_OBJECT * ob, FL_Coord * x, 8091 FL_Coord * y, FL_Coord * w, FL_Coord * h) 8092 """) 8093 x, px = make_FL_Coord_and_pointer() 8094 y, py = make_FL_Coord_and_pointer() 8095 w, pw = make_FL_Coord_and_pointer() 8096 h, ph = make_FL_Coord_and_pointer() 8097 keep_elem_refs(pObject, x, y, w, h, px, py, pw, ph) 8098 _fl_get_browser_dimension(pObject, px, py, pw, ph) 8099 return x, y, w, h
8100 8101
8102 -def fl_set_browser_dblclick_callback(pObject, py_CallbackPtr, argum):
8103 """ fl_set_browser_dblclick_callback(pObject, py_CallbackPtr, argum) 8104 """ 8105 8106 _fl_set_browser_dblclick_callback = cfuncproto( 8107 load_so_libforms(), "fl_set_browser_dblclick_callback", 8108 None, [cty.POINTER(FL_OBJECT), FL_CALLBACKPTR, cty.c_long], 8109 """void fl_set_browser_dblclick_callback(FL_OBJECT * ob, 8110 FL_CALLBACKPTR cb, long int a) 8111 """) 8112 largum = convert_to_long(argum) 8113 c_CallbackPtr = FL_CALLBACKPTR(py_CallbackPtr) 8114 keep_cfunc_refs(c_CallbackPtr, py_CallbackPtr) 8115 keep_elem_refs(pObject, argum, largum) 8116 _fl_set_browser_dblclick_callback(pObject, c_CallbackPtr, largum)
8117 8118
8119 -def fl_get_browser_xoffset(pObject):
8120 """ fl_get_browser_xoffset(pObject) -> coord num. 8121 8122 @param pObject : pointer to browser object 8123 """ 8124 8125 _fl_get_browser_xoffset = cfuncproto( 8126 load_so_libforms(), "fl_get_browser_xoffset", 8127 FL_Coord, [cty.POINTER(FL_OBJECT)], 8128 """FL_Coord fl_get_browser_xoffset(FL_OBJECT * ob) 8129 """) 8130 keep_elem_refs(pObject) 8131 retval = _fl_get_browser_xoffset(pObject) 8132 return retval
8133 8134
8135 -def fl_get_browser_rel_xoffset(pObject):
8136 """ fl_get_browser_rel_xoffset(pObject) -> num. 8137 8138 @param pObject : pointer to browser object 8139 """ 8140 8141 _fl_get_browser_rel_xoffset = cfuncproto( 8142 load_so_libforms(), "fl_get_browser_rel_xoffset", 8143 cty.c_double, [cty.POINTER(FL_OBJECT)], 8144 """double fl_get_browser_rel_xoffset(FL_OBJECT * ob) 8145 """) 8146 keep_elem_refs(pObject) 8147 retval = _fl_get_browser_rel_xoffset(pObject) 8148 return retval
8149 8150
8151 -def fl_set_browser_xoffset(pObject, npixels):
8152 """ fl_set_browser_xoffset(pObject, npixels) 8153 """ 8154 8155 _fl_set_browser_xoffset = cfuncproto( 8156 load_so_libforms(), "fl_set_browser_xoffset", 8157 None, [cty.POINTER(FL_OBJECT), FL_Coord], 8158 """void fl_set_browser_xoffset(FL_OBJECT * ob, FL_Coord npixels) 8159 """) 8160 inpixels = convert_to_FL_Coord(npixels) 8161 keep_elem_refs(pObject, npixels, inpixels) 8162 _fl_set_browser_xoffset(pObject, inpixels)
8163 8164
8165 -def fl_set_browser_rel_xoffset(pObject, val):
8166 """ fl_set_browser_rel_xoffset(pObject, val) 8167 """ 8168 8169 _fl_set_browser_rel_xoffset = cfuncproto( 8170 load_so_libforms(), "fl_set_browser_rel_xoffset", 8171 None, [cty.POINTER(FL_OBJECT), cty.c_double], 8172 """void fl_set_browser_rel_xoffset(FL_OBJECT * ob, double val) 8173 """) 8174 fval = convert_to_double(val) 8175 keep_elem_refs(pObject, val, fval) 8176 _fl_set_browser_rel_xoffset(pObject, fval)
8177 8178
8179 -def fl_get_browser_yoffset(pObject):
8180 """ fl_get_browser_yoffset(pObject) -> coord num. 8181 """ 8182 8183 _fl_get_browser_yoffset = cfuncproto( 8184 load_so_libforms(), "fl_get_browser_yoffset", 8185 FL_Coord, [cty.POINTER(FL_OBJECT)], 8186 """FL_Coord fl_get_browser_yoffset(FL_OBJECT * ob) 8187 """) 8188 keep_elem_refs(pObject) 8189 retval = _fl_get_browser_yoffset(pObject) 8190 return retval
8191 8192
8193 -def fl_get_browser_rel_yoffset(pObject):
8194 """ fl_get_browser_rel_yoffset(pObject) -> num. 8195 """ 8196 8197 _fl_get_browser_rel_yoffset = cfuncproto( 8198 load_so_libforms(), "fl_get_browser_rel_yoffset", 8199 cty.c_double, [cty.POINTER(FL_OBJECT)], 8200 """double fl_get_browser_rel_yoffset(FL_OBJECT * ob) 8201 """) 8202 keep_elem_refs(pObject) 8203 retval = _fl_get_browser_rel_yoffset(pObject) 8204 return retval
8205 8206
8207 -def fl_set_browser_yoffset(pObject, npixels):
8208 """ fl_set_browser_yoffset(pObject, npixels) 8209 """ 8210 8211 _fl_set_browser_yoffset = cfuncproto( 8212 load_so_libforms(), "fl_set_browser_yoffset", 8213 None, [cty.POINTER(FL_OBJECT), FL_Coord], 8214 """void fl_set_browser_yoffset(FL_OBJECT * ob, FL_Coord npixels) 8215 """) 8216 inpixels = convert_to_FL_Coord(npixels) 8217 keep_elem_refs(pObject, npixels, inpixels) 8218 _fl_set_browser_yoffset(pObject, inpixels)
8219 8220
8221 -def fl_set_browser_rel_yoffset(pObject, val):
8222 """ fl_set_browser_rel_yoffset(pObject, val) 8223 """ 8224 8225 _fl_set_browser_rel_yoffset = cfuncproto( 8226 load_so_libforms(), "fl_set_browser_rel_yoffset", 8227 None, [cty.POINTER(FL_OBJECT), cty.c_double], 8228 """void fl_set_browser_rel_yoffset(FL_OBJECT * ob, double val) 8229 """) 8230 fval = convert_to_double(val) 8231 keep_elem_refs(pObject, val, fval) 8232 _fl_set_browser_rel_yoffset(pObject, fval)
8233 8234
8235 -def fl_set_browser_scrollbarsize(pObject, hh, vw):
8236 """ fl_set_browser_scrollbarsize(pObject, hh, vw) 8237 """ 8238 8239 _fl_set_browser_scrollbarsize = cfuncproto( 8240 load_so_libforms(), "fl_set_browser_scrollbarsize", 8241 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 8242 """void fl_set_browser_scrollbarsize(FL_OBJECT * ob, 8243 int hh, int vw) 8244 """) 8245 ihh = convert_to_int(hh) 8246 ivw = convert_to_int(vw) 8247 keep_elem_refs(pObject, hh, vw, ihh, ivw) 8248 _fl_set_browser_scrollbarsize(pObject, ihh, ivw)
8249 8250
8251 -def fl_show_browser_line(pObject, line):
8252 """ 8253 fl_show_browser_line(pObject, line) 8254 8255 Bring a browser line into view. 8256 8257 @param pObject : pointer to browser object 8258 @param line : line to show 8259 """ 8260 8261 _fl_show_browser_line = cfuncproto( 8262 load_so_libforms(), "fl_show_browser_line", 8263 None, [cty.POINTER(FL_OBJECT), cty.c_int], 8264 """void fl_show_browser_line(FL_OBJECT * ob, int j) 8265 """) 8266 iline = convert_to_int(line) 8267 keep_elem_refs(pObject, line, iline) 8268 _fl_show_browser_line(pObject, iline)
8269 8270
8271 -def fl_set_default_browser_maxlinelength(n):
8272 """ 8273 fl_set_default_browser_maxlinelength(n) -> length num. 8274 8275 Inactive function. Returns always 0 8276 8277 @param n : unused parameter 8278 """ 8279 8280 _fl_set_default_browser_maxlinelength = cfuncproto( 8281 load_so_libforms(), "fl_set_default_browser_maxlinelength", 8282 cty.c_int, [cty.c_int], 8283 """int fl_set_default_browser_maxlinelength(int n): 8284 """) 8285 inum = convert_to_int(n) 8286 keep_elem_refs(n, inum) 8287 retval = _fl_set_default_browser_maxlinelength(inum) 8288 return retval
8289 8290 8291 FL_BROWSER_SCROLL_CALLBACK = cty.CFUNCTYPE(None, cty.POINTER(FL_OBJECT), 8292 cty.c_int, cty.c_void_p) 8293
8294 -def fl_set_browser_hscroll_callback(pObject, py_BrowserScrollCallback, data):
8295 """ 8296 fl_set_browser_hscroll_callback(pObject, py_BrowserScrollCallback, 8297 data) 8298 8299 @param pObject : pointer to browser object 8300 @param py_BrowserScrollCallback : python function, fn(pObject, num, 8301 data) 8302 @param data : user data argument 8303 """ 8304 8305 _fl_set_browser_hscroll_callback = cfuncproto( 8306 load_so_libforms(), "fl_set_browser_hscroll_callback", 8307 None, [cty.POINTER(FL_OBJECT), FL_BROWSER_SCROLL_CALLBACK, 8308 cty.c_void_p], 8309 """void fl_set_browser_hscroll_callback(FL_OBJECT * ob, 8310 FL_BROWSER_SCROLL_CALLBACK cb, void * data) 8311 """) 8312 c_BrowserScrollCallback = FL_BROWSER_SCROLL_CALLBACK( \ 8313 py_BrowserScrollCallback) 8314 pdata = cty.cast(data, cty.c_void_p) 8315 keep_cfunc_refs(c_BrowserScrollCallback, py_BrowserScrollCallback) 8316 keep_elem_refs(pObject, data, pdata) 8317 _fl_set_browser_hscroll_callback(pObject, c_BrowserScrollCallback, pdata)
8318 8319
8320 -def fl_set_browser_vscroll_callback(pObject, py_BrowserScrollCallback, data):
8321 """ 8322 fl_set_browser_vscroll_callback(pObject, py_BrowserScrollCallback, 8323 data) 8324 8325 @param pObject : pointer to browser object 8326 @param py_BrowserScrollCallback : python function, fn(pObject, num, 8327 data) 8328 @param data : user data argument 8329 """ 8330 8331 _fl_set_browser_vscroll_callback = cfuncproto( 8332 load_so_libforms(), "fl_set_browser_vscroll_callback", 8333 None, [cty.POINTER(FL_OBJECT), FL_BROWSER_SCROLL_CALLBACK, 8334 cty.c_void_p], 8335 """void fl_set_browser_vscroll_callback(FL_OBJECT * ob, 8336 FL_BROWSER_SCROLL_CALLBACK cb, void * data) 8337 """) 8338 c_BrowserScrollCallback = FL_BROWSER_SCROLL_CALLBACK( \ 8339 py_BrowserScrollCallback) 8340 pdata = cty.cast(data, cty.c_void_p) 8341 keep_cfunc_refs(c_BrowserScrollCallback, py_BrowserScrollCallback) 8342 keep_elem_refs(pObject, data, pdata) 8343 _fl_set_browser_vscroll_callback(pObject, c_BrowserScrollCallback, pdata)
8344 8345
8346 -def fl_get_browser_line_yoffset(pObject, line):
8347 """ fl_get_browser_line_yoffset(pObject, line) -> num. 8348 """ 8349 8350 _fl_get_browser_line_yoffset = cfuncproto( 8351 load_so_libforms(), "fl_get_browser_line_yoffset", 8352 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 8353 """int fl_get_browser_line_yoffset(FL_OBJECT * obj, int line) 8354 """) 8355 iline = convert_to_int(line) 8356 keep_elem_refs(pObject, line, iline) 8357 retval = _fl_get_browser_line_yoffset(pObject, iline) 8358 return retval
8359 8360
8361 -def fl_get_browser_hscroll_callback(pObject):
8362 """ fl_get_browser_hscroll_callback(pObject) -> callback 8363 """ 8364 8365 _fl_get_browser_hscroll_callback = cfuncproto( 8366 load_so_libforms(), "fl_get_browser_hscroll_callback", 8367 FL_BROWSER_SCROLL_CALLBACK, [cty.POINTER(FL_OBJECT)], 8368 """FL_BROWSER_SCROLL_CALLBACK fl_get_browser_hscroll_callback( 8369 FL_OBJECT * ob) 8370 """) 8371 keep_elem_refs(pObject) 8372 retval = _fl_get_browser_hscroll_callback(pObject) 8373 return retval
8374 8375
8376 -def fl_get_browser_vscroll_callback(pObject):
8377 """ fl_get_browser_vscroll_callback(pObject) -> callback 8378 """ 8379 8380 _fl_get_browser_vscroll_callback = cfuncproto( 8381 load_so_libforms(), "fl_get_browser_vscroll_callback", 8382 FL_BROWSER_SCROLL_CALLBACK, [cty.POINTER(FL_OBJECT)], 8383 """FL_BROWSER_SCROLL_CALLBACK fl_get_browser_vscroll_callback( 8384 FL_OBJECT * ob) 8385 """) 8386 keep_elem_refs(pObject) 8387 retval = _fl_get_browser_vscroll_callback(pObject) 8388 return retval
8389 8390 8391 8392 ############################################################# 8393 # forms.h (button.h) 8394 # All Buttons: regular button, light button and round button 8395 ############################################################# 8396 8397 # Routines 8398
8399 -def fl_create_button(buttontype, x, y, w, h, label):
8400 """ fl_create_button(buttontype, x, y, w, h, label) -> pObject 8401 8402 Creates a button object. 8403 8404 @param buttontype : type of button object to be created 8405 @param x : horizontal position of button (upper-left corner) 8406 @param x : vertical position of button (upper-left corner) 8407 @param w : width of button in pixels 8408 @param h : height of button in pixels 8409 @param label : text label of button 8410 """ 8411 8412 _fl_create_button = cfuncproto( 8413 load_so_libforms(), "fl_create_button", 8414 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8415 FL_Coord, STRING], 8416 """FL_OBJECT * fl_create_button(int type, FL_Coord x, FL_Coord y, 8417 FL_Coord w, FL_Coord h, const char * label) 8418 """) 8419 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8420 ibuttontype = convert_to_int(buttontype) 8421 ix = convert_to_FL_Coord(x) 8422 iy = convert_to_FL_Coord(y) 8423 iw = convert_to_FL_Coord(w) 8424 ih = convert_to_FL_Coord(h) 8425 slabel = convert_to_string(label) 8426 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8427 ih, slabel) 8428 retval = _fl_create_button(ibuttontype, ix, iy, iw, ih, slabel) 8429 return retval
8430 8431
8432 -def fl_create_roundbutton(buttontype, x, y, w, h, label):
8433 """ 8434 fl_create_roundbutton(buttontype, x, y, w, h, label) -> pObject 8435 8436 @param buttontype : type of button object to be created 8437 @param x : horizontal position of button (upper-left corner) 8438 @param x : vertical position of button (upper-left corner) 8439 @param w : width of button in pixels 8440 @param h : height of button in pixels 8441 @param label : text label of button 8442 """ 8443 8444 _fl_create_roundbutton = cfuncproto( 8445 load_so_libforms(), "fl_create_roundbutton", 8446 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8447 FL_Coord, STRING], 8448 """FL_OBJECT * fl_create_roundbutton(int type, FL_Coord x, 8449 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8450 """) 8451 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8452 ibuttontype = convert_to_int(buttontype) 8453 ix = convert_to_FL_Coord(x) 8454 iy = convert_to_FL_Coord(y) 8455 iw = convert_to_FL_Coord(w) 8456 ih = convert_to_FL_Coord(h) 8457 slabel = convert_to_string(label) 8458 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8459 ih, slabel) 8460 retval = _fl_create_roundbutton(ibuttontype, ix, iy, iw, ih, slabel) 8461 return retval
8462 8463
8464 -def fl_create_round3dbutton(buttontype, x, y, w, h, label):
8465 """ 8466 fl_create_round3dbutton(buttontype, x, y, w, h, label) -> pObject 8467 8468 @param buttontype : type of button object to be created 8469 @param x : horizontal position of button (upper-left corner) 8470 @param x : vertical position of button (upper-left corner) 8471 @param w : width of button in pixels 8472 @param h : height of button in pixels 8473 @param label : text label of button 8474 """ 8475 8476 _fl_create_round3dbutton = cfuncproto( 8477 load_so_libforms(), "fl_create_round3dbutton", 8478 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8479 FL_Coord, STRING], 8480 """FL_OBJECT * fl_create_round3dbutton(int type, FL_Coord x, 8481 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8482 """) 8483 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8484 ibuttontype = convert_to_int(buttontype) 8485 ix = convert_to_FL_Coord(x) 8486 iy = convert_to_FL_Coord(y) 8487 iw = convert_to_FL_Coord(w) 8488 ih = convert_to_FL_Coord(h) 8489 slabel = convert_to_string(label) 8490 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8491 ih, slabel) 8492 retval = _fl_create_round3dbutton(ibuttontype, ix, iy, iw, ih, slabel) 8493 return retval
8494 8495
8496 -def fl_create_lightbutton(buttontype, x, y, w, h, label):
8497 """ 8498 fl_create_lightbutton(buttontype, x, y, w, h, label) -> pObject 8499 8500 @param buttontype : type of button object to be created 8501 @param x : horizontal position of button (upper-left corner) 8502 @param x : vertical position of button (upper-left corner) 8503 @param w : width of button in pixels 8504 @param h : height of button in pixels 8505 @param label : text label of button 8506 """ 8507 8508 _fl_create_lightbutton = cfuncproto( 8509 load_so_libforms(), "fl_create_lightbutton", 8510 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8511 FL_Coord, STRING], 8512 """FL_OBJECT * fl_create_lightbutton(int type, FL_Coord x, 8513 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8514 """) 8515 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8516 ibuttontype = convert_to_int(buttontype) 8517 ix = convert_to_FL_Coord(x) 8518 iy = convert_to_FL_Coord(y) 8519 iw = convert_to_FL_Coord(w) 8520 ih = convert_to_FL_Coord(h) 8521 slabel = convert_to_string(label) 8522 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8523 ih, slabel) 8524 retval = _fl_create_lightbutton(ibuttontype, ix, iy, iw, ih, slabel) 8525 return retval
8526 8527
8528 -def fl_create_checkbutton(buttontype, x, y, w, h, label):
8529 """ 8530 fl_create_checkbutton(buttontype, x, y, w, h, label) -> pObject 8531 8532 Creates a checkbutton object. 8533 8534 @param buttontype : type of button object to be created 8535 @param x : horizontal position of button (upper-left corner) 8536 @param x : vertical position of button (upper-left corner) 8537 @param w : width of button in pixels 8538 @param h : height of button in pixels 8539 @param label : text label of button 8540 """ 8541 8542 _fl_create_checkbutton = cfuncproto( 8543 load_so_libforms(), "fl_create_checkbutton", 8544 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8545 FL_Coord, STRING], 8546 """FL_OBJECT * fl_create_checkbutton(int type, FL_Coord x, 8547 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8548 """) 8549 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8550 ibuttontype = convert_to_int(buttontype) 8551 ix = convert_to_FL_Coord(x) 8552 iy = convert_to_FL_Coord(y) 8553 iw = convert_to_FL_Coord(w) 8554 ih = convert_to_FL_Coord(h) 8555 slabel = convert_to_string(label) 8556 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8557 ih, slabel) 8558 retval = _fl_create_checkbutton(ibuttontype, ix, iy, iw, ih, slabel) 8559 return retval
8560 8561
8562 -def fl_create_bitmapbutton(buttontype, x, y, w, h, label):
8563 """ 8564 fl_create_bitmapbutton(buttontype, x, y, w, h, label) -> pObject 8565 8566 @param buttontype : type of button object to be created 8567 @param x : horizontal position of button (upper-left corner) 8568 @param x : vertical position of button (upper-left corner) 8569 @param w : width of button in pixels 8570 @param h : height of button in pixels 8571 @param label : text label of button 8572 """ 8573 8574 _fl_create_bitmapbutton = cfuncproto( 8575 load_so_libforms(), "fl_create_bitmapbutton", 8576 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8577 FL_Coord, STRING], 8578 """FL_OBJECT * fl_create_bitmapbutton(int type, FL_Coord x, 8579 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8580 """) 8581 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8582 ibuttontype = convert_to_int(buttontype) 8583 ix = convert_to_FL_Coord(x) 8584 iy = convert_to_FL_Coord(y) 8585 iw = convert_to_FL_Coord(w) 8586 ih = convert_to_FL_Coord(h) 8587 slabel = convert_to_string(label) 8588 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8589 ih, slabel) 8590 retval = _fl_create_bitmapbutton(ibuttontype, ix, iy, iw, ih, slabel) 8591 return retval
8592 8593
8594 -def fl_create_pixmapbutton(buttontype, x, y, w, h, label):
8595 """ 8596 fl_create_pixmapbutton(buttontype, x, y, w, h, label) -> pObject 8597 8598 @param buttontype : type of button object to be created 8599 @param x : horizontal position of button (upper-left corner) 8600 @param x : vertical position of button (upper-left corner) 8601 @param w : width of button in pixels 8602 @param h : height of button in pixels 8603 @param label : text label of button 8604 """ 8605 8606 _fl_create_pixmapbutton = cfuncproto( 8607 load_so_libforms(), "fl_create_pixmapbutton", 8608 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8609 FL_Coord, STRING], 8610 """FL_OBJECT * fl_create_pixmapbutton(int type, FL_Coord x, 8611 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8612 """) 8613 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8614 ibuttontype = convert_to_int(buttontype) 8615 ix = convert_to_FL_Coord(x) 8616 iy = convert_to_FL_Coord(y) 8617 iw = convert_to_FL_Coord(w) 8618 ih = convert_to_FL_Coord(h) 8619 slabel = convert_to_string(label) 8620 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8621 ih, slabel) 8622 retval = _fl_create_pixmapbutton(ibuttontype, ix, iy, iw, ih, slabel) 8623 return retval
8624 8625
8626 -def fl_create_scrollbutton(buttontype, x, y, w, h, label):
8627 """ 8628 fl_create_scrollbutton(buttontype, x, y, w, h, label) -> pObject 8629 8630 @param buttontype : type of button object to be created 8631 @param x : horizontal position of button (upper-left corner) 8632 @param x : vertical position of button (upper-left corner) 8633 @param w : width of button in pixels 8634 @param h : height of button in pixels 8635 @param label : text label of button 8636 """ 8637 8638 _fl_create_scrollbutton = cfuncproto( 8639 load_so_libforms(), "fl_create_scrollbutton", 8640 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8641 FL_Coord, STRING], 8642 """FL_OBJECT * fl_create_scrollbutton(int type, FL_Coord x, 8643 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8644 """) 8645 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8646 ibuttontype = convert_to_int(buttontype) 8647 ix = convert_to_FL_Coord(x) 8648 iy = convert_to_FL_Coord(y) 8649 iw = convert_to_FL_Coord(w) 8650 ih = convert_to_FL_Coord(h) 8651 slabel = convert_to_string(label) 8652 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8653 ih, slabel) 8654 retval = _fl_create_scrollbutton(ibuttontype, ix, iy, iw, ih, slabel) 8655 return retval
8656 8657
8658 -def fl_create_labelbutton(buttontype, x, y, w, h, label):
8659 """ 8660 fl_create_labelbutton(buttontype, x, y, w, h, label) -> pObject 8661 8662 @param buttontype : type of button object to be created 8663 @param x : horizontal position of button (upper-left corner) 8664 @param x : vertical position of button (upper-left corner) 8665 @param w : width of button in pixels 8666 @param h : height of button in pixels 8667 @param label : text label of button 8668 """ 8669 8670 _fl_create_labelbutton = cfuncproto( 8671 load_so_libforms(), "fl_create_labelbutton", 8672 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8673 FL_Coord, STRING], 8674 """FL_OBJECT * fl_create_labelbutton(int type, FL_Coord x, 8675 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8676 """) 8677 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8678 ibuttontype = convert_to_int(buttontype) 8679 ix = convert_to_FL_Coord(x) 8680 iy = convert_to_FL_Coord(y) 8681 iw = convert_to_FL_Coord(w) 8682 ih = convert_to_FL_Coord(h) 8683 slabel = convert_to_string(label) 8684 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8685 ih, slabel) 8686 retval = _fl_create_labelbutton(ibuttontype, ix, iy, iw, ih, slabel) 8687 return retval
8688 8689
8690 -def fl_add_roundbutton(buttontype, x, y, w, h, label):
8691 """ 8692 fl_add_roundbutton(buttontype, x, y, w, h, label) -> pObject 8693 8694 @param buttontype : type of button object to be added 8695 @param x : horizontal position of button (upper-left corner) 8696 @param x : vertical position of button (upper-left corner) 8697 @param w : width of button in pixels 8698 @param h : height of button in pixels 8699 @param label : text label of button 8700 """ 8701 8702 _fl_add_roundbutton = cfuncproto( 8703 load_so_libforms(), "fl_add_roundbutton", 8704 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8705 FL_Coord, STRING], 8706 """FL_OBJECT * fl_add_roundbutton(int type, FL_Coord x, 8707 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8708 """) 8709 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8710 ibuttontype = convert_to_int(buttontype) 8711 ix = convert_to_FL_Coord(x) 8712 iy = convert_to_FL_Coord(y) 8713 iw = convert_to_FL_Coord(w) 8714 ih = convert_to_FL_Coord(h) 8715 slabel = convert_to_string(label) 8716 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8717 ih, slabel) 8718 retval = _fl_add_roundbutton(ibuttontype, ix, iy, iw, ih, slabel) 8719 return retval
8720 8721
8722 -def fl_add_round3dbutton(buttontype, x, y, w, h, label):
8723 """ 8724 fl_add_round3dbutton(buttontype, x, y, w, h, label) -> pObject 8725 8726 @param buttontype : type of button object to be added 8727 @param x : horizontal position of button (upper-left corner) 8728 @param x : vertical position of button (upper-left corner) 8729 @param w : width of button in pixels 8730 @param h : height of button in pixels 8731 @param label : text label of button 8732 """ 8733 8734 _fl_add_round3dbutton = cfuncproto( 8735 load_so_libforms(), "fl_add_round3dbutton", 8736 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8737 FL_Coord, STRING], 8738 """FL_OBJECT * fl_add_round3dbutton(int type, FL_Coord x, 8739 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8740 """) 8741 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8742 ibuttontype = convert_to_int(buttontype) 8743 ix = convert_to_FL_Coord(x) 8744 iy = convert_to_FL_Coord(y) 8745 iw = convert_to_FL_Coord(w) 8746 ih = convert_to_FL_Coord(h) 8747 slabel = convert_to_string(label) 8748 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8749 ih, slabel) 8750 retval = _fl_add_round3dbutton(ibuttontype, ix, iy, iw, ih, slabel) 8751 return retval
8752 8753
8754 -def fl_add_lightbutton(buttontype, x, y, w, h, label):
8755 """ 8756 fl_add_lightbutton(buttontype, x, y, w, h, label) -> pObject 8757 8758 @param buttontype : type of button object to be added 8759 @param x : horizontal position of button (upper-left corner) 8760 @param x : vertical position of button (upper-left corner) 8761 @param w : width of button in pixels 8762 @param h : height of button in pixels 8763 @param label : text label of button 8764 """ 8765 8766 _fl_add_lightbutton = cfuncproto( 8767 load_so_libforms(), "fl_add_lightbutton", 8768 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8769 FL_Coord, STRING], 8770 """FL_OBJECT * fl_add_lightbutton(int type, FL_Coord x, FL_Coord y, 8771 FL_Coord w, FL_Coord h, const char * label) 8772 """) 8773 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8774 ibuttontype = convert_to_int(buttontype) 8775 ix = convert_to_FL_Coord(x) 8776 iy = convert_to_FL_Coord(y) 8777 iw = convert_to_FL_Coord(w) 8778 ih = convert_to_FL_Coord(h) 8779 slabel = convert_to_string(label) 8780 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8781 ih, slabel) 8782 retval = _fl_add_lightbutton(ibuttontype, ix, iy, iw, ih, slabel) 8783 return retval
8784 8785
8786 -def fl_add_checkbutton(buttontype, x, y, w, h, label):
8787 """ 8788 fl_add_checkbutton(buttontype, x, y, w, h, label) -> pObject 8789 8790 Adds a checkbutton object. 8791 8792 @param buttontype : type of button object to be added 8793 @param x : horizontal position of button (upper-left corner) 8794 @param x : vertical position of button (upper-left corner) 8795 @param w : width of button in pixels 8796 @param h : height of button in pixels 8797 @param label : text label of button 8798 """ 8799 8800 _fl_add_checkbutton = cfuncproto( 8801 load_so_libforms(), "fl_add_checkbutton", 8802 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8803 FL_Coord, STRING], 8804 """FL_OBJECT * fl_add_checkbutton(int type, FL_Coord x, FL_Coord y, 8805 FL_Coord w, FL_Coord h, const char * label) 8806 """) 8807 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8808 ibuttontype = convert_to_int(buttontype) 8809 ix = convert_to_FL_Coord(x) 8810 iy = convert_to_FL_Coord(y) 8811 iw = convert_to_FL_Coord(w) 8812 ih = convert_to_FL_Coord(h) 8813 slabel = convert_to_string(label) 8814 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8815 ih, slabel) 8816 retval = _fl_add_checkbutton(ibuttontype, ix, iy, iw, ih, slabel) 8817 return retval
8818 8819
8820 -def fl_add_button(buttontype, x, y, w, h, label):
8821 """ 8822 fl_add_button(buttontype, x, y, w, h, label) -> pObject 8823 8824 Adds a button to the current form. 8825 8826 @param buttontype : type of button object to be added 8827 @param x : horizontal position of button (upper-left corner) 8828 @param x : vertical position of button (upper-left corner) 8829 @param w : width of button in pixels 8830 @param h : height of button in pixels 8831 @param label : text label of button 8832 """ 8833 8834 _fl_add_button = cfuncproto( 8835 load_so_libforms(), "fl_add_button", 8836 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8837 FL_Coord, STRING], 8838 """FL_OBJECT * fl_add_button(int type, FL_Coord x, FL_Coord y, 8839 FL_Coord w, FL_Coord h, const char * label) 8840 """) 8841 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8842 ibuttontype = convert_to_int(buttontype) 8843 ix = convert_to_FL_Coord(x) 8844 iy = convert_to_FL_Coord(y) 8845 iw = convert_to_FL_Coord(w) 8846 ih = convert_to_FL_Coord(h) 8847 slabel = convert_to_string(label) 8848 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8849 ih, slabel) 8850 retval = _fl_add_button(ibuttontype, ix, iy, iw, ih, slabel) 8851 return retval
8852 8853
8854 -def fl_add_bitmapbutton(buttontype, x, y, w, h, label):
8855 """ 8856 fl_add_bitmapbutton(buttontype, x, y, w, h, label) -> pObject 8857 8858 @param buttontype : type of button object to be added 8859 @param x : horizontal position of button (upper-left corner) 8860 @param x : vertical position of button (upper-left corner) 8861 @param w : width of button in pixels 8862 @param h : height of button in pixels 8863 @param label : text label of button 8864 """ 8865 8866 _fl_add_bitmapbutton = cfuncproto( 8867 load_so_libforms(), "fl_add_bitmapbutton", 8868 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8869 FL_Coord, STRING], 8870 """FL_OBJECT * fl_add_bitmapbutton(int type, FL_Coord x, 8871 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8872 """) 8873 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8874 ibuttontype = convert_to_int(buttontype) 8875 ix = convert_to_FL_Coord(x) 8876 iy = convert_to_FL_Coord(y) 8877 iw = convert_to_FL_Coord(w) 8878 ih = convert_to_FL_Coord(h) 8879 slabel = convert_to_string(label) 8880 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8881 ih, slabel) 8882 retval = _fl_add_bitmapbutton(ibuttontype, ix, iy, iw, ih, slabel) 8883 return retval
8884 8885
8886 -def fl_add_scrollbutton(buttontype, x, y, w, h, label):
8887 """ 8888 fl_add_scrollbutton(buttontype, x, y, w, h, label) -> pObject 8889 8890 @param buttontype : type of button object to be added 8891 @param x : horizontal position of button (upper-left corner) 8892 @param x : vertical position of button (upper-left corner) 8893 @param w : width of button in pixels 8894 @param h : height of button in pixels 8895 @param label : text label of button 8896 """ 8897 8898 _fl_add_scrollbutton = cfuncproto( 8899 load_so_libforms(), "fl_add_scrollbutton", 8900 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8901 FL_Coord, STRING], 8902 """FL_OBJECT * fl_add_scrollbutton(int type, FL_Coord x, 8903 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8904 """) 8905 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8906 ibuttontype = convert_to_int(buttontype) 8907 ix = convert_to_FL_Coord(x) 8908 iy = convert_to_FL_Coord(y) 8909 iw = convert_to_FL_Coord(w) 8910 ih = convert_to_FL_Coord(h) 8911 slabel = convert_to_string(label) 8912 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8913 ih, slabel) 8914 retval = _fl_add_scrollbutton(ibuttontype, ix, iy, iw, ih, slabel) 8915 return retval
8916 8917
8918 -def fl_add_labelbutton(buttontype, x, y, w, h, label):
8919 """ 8920 fl_add_labelbutton(buttontype, x, y, w, h, label) -> pObject 8921 8922 @param buttontype : type of button object to be added 8923 @param x : horizontal position of button (upper-left corner) 8924 @param x : vertical position of button (upper-left corner) 8925 @param w : width of button in pixels 8926 @param h : height of button in pixels 8927 @param label : text label of button 8928 """ 8929 8930 _fl_add_labelbutton = cfuncproto( 8931 load_so_libforms(), "fl_add_labelbutton", 8932 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8933 FL_Coord, STRING], 8934 """FL_OBJECT * fl_add_labelbutton(int type, FL_Coord x, 8935 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8936 """) 8937 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8938 ibuttontype = convert_to_int(buttontype) 8939 ix = convert_to_FL_Coord(x) 8940 iy = convert_to_FL_Coord(y) 8941 iw = convert_to_FL_Coord(w) 8942 ih = convert_to_FL_Coord(h) 8943 slabel = convert_to_string(label) 8944 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 8945 ih, slabel) 8946 retval = _fl_add_labelbutton(ibuttontype, ix, iy, iw, ih, slabel) 8947 return retval
8948 8949 8950 fl_set_bitmapbutton_file = fl_set_bitmap_file 8951 8952
8953 -def fl_set_bitmapbutton_data(pObject, w, h, bits):
8954 """ fl_set_bitmapbutton_data(pObject, w, h, bits) 8955 """ 8956 8957 _fl_set_bitmapbutton_data = cfuncproto( 8958 load_so_libforms(), "fl_set_bitmapbutton_data", 8959 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int, 8960 cty.POINTER(cty.c_ubyte)], 8961 """void fl_set_bitmapbutton_data(FL_OBJECT * ob, int w, int h, 8962 unsigned char * bits) 8963 """) 8964 iw = convert_to_int(w) 8965 ih = convert_to_int(h) 8966 pbits = cty.cast(bits, cty.POINTER(cty.c_ubyte)) 8967 keep_elem_refs(pObject, w, h, bits, iw, ih, pbits) 8968 _fl_set_bitmapbutton_data(pObject, iw, ih, pbits)
8969 8970 8971 fl_set_bitmapbutton_datafile = fl_set_bitmapbutton_file 8972 8973
8974 -def fl_add_pixmapbutton(buttontype, x, y, w, h, label):
8975 """ 8976 fl_add_pixmapbutton(buttontype, x, y, w, h, label) -> pObject 8977 8978 @param buttontype : type of button object to be added 8979 @param x : horizontal position of button (upper-left corner) 8980 @param x : vertical position of button (upper-left corner) 8981 @param w : width of button in pixels 8982 @param h : height of button in pixels 8983 @param label : text label of button 8984 """ 8985 8986 _fl_add_pixmapbutton = cfuncproto( 8987 load_so_libforms(), "fl_add_pixmapbutton", 8988 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 8989 FL_Coord, STRING], 8990 """FL_OBJECT * fl_add_pixmapbutton(int type, FL_Coord x, 8991 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 8992 """) 8993 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 8994 ibuttontype = convert_to_int(buttontype) 8995 ix = convert_to_FL_Coord(x) 8996 iy = convert_to_FL_Coord(y) 8997 iw = convert_to_FL_Coord(w) 8998 ih = convert_to_FL_Coord(h) 8999 slabel = convert_to_string(label) 9000 keep_elem_refs(buttontype, x, y, w, h, label, ibuttontype, ix, iy, iw, 9001 ih, slabel) 9002 retval = _fl_add_pixmapbutton(ibuttontype, ix, iy, iw, ih, slabel) 9003 return retval
9004 9005
9006 -def fl_set_pixmapbutton_focus_outline(pObject, yes):
9007 """ fl_set_pixmapbutton_focus_outline(pObject, yes) 9008 """ 9009 9010 _fl_set_pixmapbutton_focus_outline = cfuncproto( 9011 load_so_libforms(), "fl_set_pixmapbutton_focus_outline", 9012 None, [cty.POINTER(FL_OBJECT), cty.c_int], 9013 """void fl_set_pixmapbutton_focus_outline(FL_OBJECT * ob, int yes) 9014 """) 9015 iyes = convert_to_int(yes) 9016 keep_elem_refs(pObject, yes, iyes) 9017 _fl_set_pixmapbutton_focus_outline(pObject, iyes)
9018 9019 9020 fl_set_pixmapbutton_data = fl_set_pixmap_data 9021 fl_set_pixmapbutton_file = fl_set_pixmap_file 9022 fl_set_pixmapbutton_pixmap = fl_set_pixmap_pixmap 9023 fl_get_pixmapbutton_pixmap = fl_get_pixmap_pixmap 9024 fl_set_pixmapbutton_align = fl_set_pixmap_align 9025 fl_free_pixmapbutton_pixmap = fl_free_pixmap_pixmap 9026 fl_set_pixmapbutton_datafile = fl_set_pixmapbutton_file 9027 fl_set_pixmapbutton_show_focus = fl_set_pixmapbutton_focus_outline 9028 9029
9030 -def fl_set_pixmapbutton_focus_data(pObject, bits):
9031 """ fl_set_pixmapbutton_focus_data(pObject, bits) 9032 """ 9033 9034 _fl_set_pixmapbutton_focus_data = cfuncproto( 9035 load_so_libforms(), "fl_set_pixmapbutton_focus_data", 9036 None, [cty.POINTER(FL_OBJECT), cty.POINTER(STRING)], 9037 """void fl_set_pixmapbutton_focus_data(FL_OBJECT * ob, 9038 char * * bits) 9039 """) 9040 keep_elem_refs(pObject, bits) 9041 _fl_set_pixmapbutton_focus_data(pObject, bits)
9042 9043
9044 -def fl_set_pixmapbutton_focus_file(pObject, fname):
9045 """ fl_set_pixmapbutton_focus_file(pObject, fname) 9046 """ 9047 9048 _fl_set_pixmapbutton_focus_file = cfuncproto( 9049 load_so_libforms(), "fl_set_pixmapbutton_focus_file", 9050 None, [cty.POINTER(FL_OBJECT), STRING], 9051 """void fl_set_pixmapbutton_focus_file(FL_OBJECT * ob, 9052 const char * fname) 9053 """) 9054 sfname = convert_to_string(fname) 9055 keep_elem_refs(pObject, fname, sfname) 9056 _fl_set_pixmapbutton_focus_file(pObject, sfname)
9057 9058
9059 -def fl_set_pixmapbutton_focus_pixmap(pObject, idnum, mask):
9060 """ fl_set_pixmapbutton_focus_pixmap(pObject, idnum, mask) 9061 """ 9062 9063 _fl_set_pixmapbutton_focus_pixmap = cfuncproto( 9064 load_so_libforms(), "fl_set_pixmapbutton_focus_pixmap", 9065 None, [cty.POINTER(FL_OBJECT), Pixmap, Pixmap], 9066 """void fl_set_pixmapbutton_focus_pixmap(FL_OBJECT * ob, 9067 Pixmap id, Pixmap mask) 9068 """) 9069 ulidnum = convert_to_ulong(idnum) 9070 ulmask = convert_to_ulong(mask) 9071 keep_elem_refs(pObject, idnum, mask, ulidnum, ulmask) 9072 _fl_set_pixmapbutton_focus_pixmap(pObject, ulidnum, ulmask)
9073 9074
9075 -def fl_get_button(pObject):
9076 """ 9077 fl_get_button(pObject) -> num. 9078 9079 Returns the value of the button. 9080 9081 @param pObject : pointer to button object 9082 """ 9083 9084 _fl_get_button = cfuncproto( 9085 load_so_libforms(), "fl_get_button", 9086 cty.c_int, [cty.POINTER(FL_OBJECT)], 9087 """int fl_get_button(FL_OBJECT * ob) 9088 """) 9089 keep_elem_refs(pObject) 9090 retval = _fl_get_button(pObject) 9091 return retval
9092 9093
9094 -def fl_set_button(pObject, pushed):
9095 """ 9096 fl_set_button(pObject, pushed) 9097 9098 Sets the button state (not pushed/pushed). 9099 9100 @param pObject : pointer to button object 9101 @param pushed : state of button to be set (0|1) 9102 """ 9103 9104 _fl_set_button = cfuncproto( 9105 load_so_libforms(), "fl_set_button", 9106 None, [cty.POINTER(FL_OBJECT), cty.c_int], 9107 """void fl_set_button(FL_OBJECT * ob, int pushed) 9108 """) 9109 ipushed = convert_to_int(pushed) 9110 keep_elem_refs(pObject, pushed, ipushed) 9111 _fl_set_button(pObject, ipushed)
9112 9113
9114 -def fl_get_button_numb(pObject):
9115 """ 9116 fl_get_button_numb(pObject) -> num. 9117 9118 Returns the number of the last used mouse button. fl_mouse_button 9119 will also return the mouse number. 9120 9121 @param pObject : pointer to button object 9122 """ 9123 9124 _fl_get_button_numb = cfuncproto( 9125 load_so_libforms(), "fl_get_button_numb", 9126 cty.c_int, [cty.POINTER(FL_OBJECT)], 9127 """int fl_get_button_numb(FL_OBJECT * ob) 9128 """) 9129 keep_elem_refs(pObject) 9130 retval = _fl_get_button_numb(pObject) 9131 return retval
9132 9133 9134 fl_set_button_shortcut = fl_set_object_shortcut 9135 9136
9137 -def fl_create_generic_button(objclass, buttontype, x, y, w, h, label):
9138 """ 9139 fl_create_generic_button(objclass, buttontype, x, y, w, h, label) -> pObject 9140 9141 Creates a generic button object. 9142 9143 @param objclass : value of a new button class 9144 @param buttontype : type of button object to be created 9145 @param x : horizontal position of button (upper-left corner) 9146 @param x : vertical position of button (upper-left corner) 9147 @param w : width of button in pixels 9148 @param h : height of button in pixels 9149 @param label : text label of button 9150 """ 9151 9152 _fl_create_generic_button = cfuncproto( 9153 load_so_libforms(), "fl_create_generic_button", 9154 cty.POINTER(FL_OBJECT), [cty.c_int, cty.c_int, FL_Coord, FL_Coord, 9155 FL_Coord, FL_Coord, STRING], 9156 """FL_OBJECT * fl_create_generic_button(int objclass, int type, 9157 FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, 9158 const char * label) 9159 """) 9160 check_admitted_listvalues(buttontype, BUTTONTYPE_list) 9161 iobjclass = convert_to_int(objclass) 9162 ibuttontype = convert_to_int(buttontype) 9163 ix = convert_to_FL_Coord(x) 9164 iy = convert_to_FL_Coord(y) 9165 iw = convert_to_FL_Coord(w) 9166 ih = convert_to_FL_Coord(h) 9167 slabel = convert_to_string(label) 9168 keep_elem_refs(objclass, buttontype, x, y, w, h, label, iobjclass, 9169 ibuttontype, ix, iy, iw, ih, slabel) 9170 retval = _fl_create_generic_button(iobjclass, ibuttontype, ix, iy, 9171 iw, ih, slabel) 9172 return retval
9173 9174 9175 FL_DrawButton = cty.CFUNCTYPE(None, cty.POINTER(FL_OBJECT)) 9176 FL_CleanupButton = cty.CFUNCTYPE(None, cty.POINTER(FL_BUTTON_SPEC)) 9177 9178 FL_DRAWBUTTON = FL_DrawButton 9179 FL_CLEANUPBUTTON = FL_CleanupButton 9180
9181 -def fl_add_button_class(bclass, py_DrawButton, py_CleanupButton):
9182 """ 9183 fl_add_button_class(bclass, py_DrawButton, py_CleanupButton) 9184 9185 Associates a button class with a drawing function. 9186 9187 @param bclass : value of a new button class 9188 @param py_DrawButton : python function to draw button, fn(pObject) 9189 @param py_CleanupButton : python function to cleanup button, 9190 fn(pButtonSpec) 9191 """ 9192 9193 _fl_add_button_class = cfuncproto( 9194 load_so_libforms(), "fl_add_button_class", 9195 None, [cty.c_int, FL_DrawButton, FL_CleanupButton], 9196 """void fl_add_button_class(int bclass, FL_DrawButton drawit, 9197 FL_CleanupButton cleanup) 9198 """) 9199 ibclass = convert_to_int(bclass) 9200 c_DrawButton = FL_DrawButton(py_DrawButton) 9201 c_CleanupButton = FL_CleanupButton(py_CleanupButton) 9202 keep_cfunc_refs(c_DrawButton, py_DrawButton, c_CleanupButton, 9203 py_CleanupButton) 9204 keep_elem_refs(bclass, ibclass) 9205 _fl_add_button_class(ibclass, c_DrawButton, c_CleanupButton)
9206 9207
9208 -def fl_set_button_mouse_buttons(pObject, buttons):
9209 """ 9210 fl_set_button_mouse_buttons(pObject, buttons) 9211 9212 Function allows to set up to which mouse buttons the button object 9213 will react. 9214 9215 @param pObject : pointer to button object 9216 @param buttons : value of mouse buttons to be set 9217 """ 9218 9219 _fl_set_button_mouse_buttons = cfuncproto( 9220 load_so_libforms(), "fl_set_button_mouse_buttons", 9221 None, [cty.POINTER(FL_OBJECT), cty.c_uint], 9222 """void fl_set_button_mouse_buttons(FL_OBJECT * ob, 9223 unsigned int buttons) 9224 """) 9225 ibuttons = convert_to_int(buttons) 9226 keep_elem_refs(pObject, buttons, ibuttons) 9227 _fl_set_button_mouse_buttons(pObject, ibuttons)
9228 9229 9230 #def fl_get_button_mouse_buttons(pObject, buttons) *API change*
9231 -def fl_get_button_mouse_buttons(pObject):
9232 """ 9233 fl_get_button_mouse_buttons(pObject) -> buttons value 9234 9235 Returns a value indicating which mouse buttons the button object 9236 will react to. 9237 9238 @param pObject : pointer to button object 9239 """ 9240 9241 _fl_get_button_mouse_buttons = cfuncproto( 9242 load_so_libforms(), "fl_get_button_mouse_buttons", 9243 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_uint)], 9244 """void fl_get_button_mouse_buttons(FL_OBJECT * ob, 9245 unsigned int * buttons) 9246 """) 9247 buttons, pbuttons = make_uint_and_pointer() 9248 keep_elem_refs(pObject, buttons, pbuttons) 9249 _fl_get_button_mouse_buttons(pObject, pbuttons) 9250 return buttons
9251 9252 9253 ####################### 9254 # forms.h (canvas.h) 9255 # Header for FL_CANVAS 9256 ####################### 9257 9258 # Interfaces 9259
9260 -def fl_create_generic_canvas(canvasclass, canvastype, x, y, w, h, label):
9261 """ 9262 fl_create_generic_canvas(canvasclass, canvastype, x, y, w, h, label) -> pObject 9263 9264 Creates a generic canvas object. 9265 9266 @param canvasclass : value of a new canvas class 9267 @param canvastype : type of canvas object to be created 9268 @param x : horizontal position of canvas (upper-left corner) 9269 @param x : vertical position of canvas (upper-left corner) 9270 @param w : width of canvas in pixels 9271 @param h : height of canvas in pixels 9272 @param label : text label of canvas 9273 """ 9274 9275 _fl_create_generic_canvas = cfuncproto( 9276 load_so_libforms(), "fl_create_generic_canvas", 9277 cty.POINTER(FL_OBJECT), [cty.c_int, cty.c_int, FL_Coord, FL_Coord, 9278 FL_Coord, FL_Coord, STRING], 9279 """FL_OBJECT * fl_create_generic_canvas(int canvas_class, 9280 int type, FL_Coord x, FL_Coord y, FL_Coord w, FL_Coord h, 9281 const char * label) 9282 """) 9283 check_admitted_listvalues(canvastype, CANVASTYPE_list) 9284 icanvasclass = convert_to_int(canvasclass) 9285 icanvastype = convert_to_int(canvastype) 9286 ix = convert_to_FL_Coord(x) 9287 iy = convert_to_FL_Coord(y) 9288 iw = convert_to_FL_Coord(w) 9289 ih = convert_to_FL_Coord(h) 9290 slabel = convert_to_string(label) 9291 keep_elem_refs(canvasclass, canvastype, x, y, w, h, label, icanvasclass, 9292 icanvastype, ix, iy, iw, ih, slabel) 9293 retval = _fl_create_generic_canvas(icanvasclass, icanvastype, ix, iy, iw, ih, 9294 slabel) 9295 return retval
9296 9297
9298 -def fl_add_canvas(canvastype, x, y, w, h, label):
9299 """ 9300 fl_add_canvas(canvastype, x, y, w, h, label) -> pObject 9301 9302 Adds a canvas object. 9303 9304 @param canvastype : type of canvas object to be added 9305 @param x : horizontal position of canvas (upper-left corner) 9306 @param x : vertical position of canvas (upper-left corner) 9307 @param w : width of canvas in pixels 9308 @param h : height of canvas in pixels 9309 @param label : text label of canvas 9310 """ 9311 9312 _fl_add_canvas = cfuncproto( 9313 load_so_libforms(), "fl_add_canvas", 9314 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 9315 FL_Coord, STRING], 9316 """FL_OBJECT * fl_add_canvas(int type, FL_Coord x, FL_Coord y, 9317 FL_Coord w, FL_Coord h, const char * label) 9318 """) 9319 check_admitted_listvalues(canvastype, CANVASTYPE_list) 9320 icanvastype = convert_to_int(canvastype) 9321 ix = convert_to_FL_Coord(x) 9322 iy = convert_to_FL_Coord(y) 9323 iw = convert_to_FL_Coord(w) 9324 ih = convert_to_FL_Coord(h) 9325 slabel = convert_to_string(label) 9326 keep_elem_refs(canvastype, x, y, w, h, label, icanvastype, ix, iy, 9327 iw, ih, slabel) 9328 retval = _fl_add_canvas(icanvastype, ix, iy, iw, ih, slabel) 9329 return retval
9330 9331
9332 -def fl_create_canvas(canvastype, x, y, w, h, label):
9333 """ 9334 fl_create_canvas(canvastype, x, y, w, h, label) -> pObject 9335 9336 Creates a canvas object. 9337 9338 @param canvastype : type of canvas object to be created 9339 @param x : horizontal position of canvas (upper-left corner) 9340 @param x : vertical position of canvas (upper-left corner) 9341 @param w : width of canvas in pixels 9342 @param h : height of canvas in pixels 9343 @param label : text label of canvas 9344 """ 9345 9346 _fl_create_canvas = cfuncproto( 9347 load_so_libforms(), "fl_create_canvas", 9348 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 9349 FL_Coord, STRING], 9350 """FL_OBJECT * fl_create_canvas(int type, FL_Coord x, FL_Coord y, 9351 FL_Coord w, FL_Coord h, const char * label) 9352 """) 9353 check_admitted_listvalues(canvastype, CANVASTYPE_list) 9354 icanvastype = convert_to_int(canvastype) 9355 ix = convert_to_FL_Coord(x) 9356 iy = convert_to_FL_Coord(y) 9357 iw = convert_to_FL_Coord(w) 9358 ih = convert_to_FL_Coord(h) 9359 slabel = convert_to_string(label) 9360 keep_elem_refs(canvastype, x, y, w, h, label, icanvastype, ix, iy, 9361 iw, ih, slabel) 9362 retval = _fl_create_canvas(icanvastype, ix, iy, iw, ih, slabel) 9363 return retval
9364 9365 9366 # backward compatibility 9367 fl_set_canvas_decoration = fl_set_object_boxtype 9368 9369
9370 -def fl_set_canvas_colormap(pObject, colormap):
9371 """ fl_set_canvas_colormap(pObject, colormap) 9372 """ 9373 9374 _fl_set_canvas_colormap = cfuncproto( 9375 load_so_libforms(), "fl_set_canvas_colormap", 9376 None, [cty.POINTER(FL_OBJECT), Colormap], 9377 """void fl_set_canvas_colormap(FL_OBJECT * ob, Colormap colormap) 9378 """) 9379 ulcolormap = convert_to_ulong(colormap) 9380 keep_elem_refs(pObject, colormap, ulcolormap) 9381 _fl_set_canvas_colormap(pObject, ulcolormap)
9382 9383
9384 -def fl_set_canvas_visual(pObject, vi):
9385 """ fl_set_canvas_visual(pObject, vi) 9386 """ 9387 9388 _fl_set_canvas_visual = cfuncproto( 9389 load_so_libforms(), "fl_set_canvas_visual", 9390 None, [cty.POINTER(FL_OBJECT), cty.POINTER(Visual)], 9391 """void fl_set_canvas_visual(FL_OBJECT * obj, Visual * vi) 9392 """) 9393 keep_elem_refs(pObject, vi) 9394 _fl_set_canvas_visual(pObject, vi)
9395 9396
9397 -def fl_set_canvas_depth(pObject, depth):
9398 """ fl_set_canvas_depth(pObject, depth) 9399 """ 9400 9401 _fl_set_canvas_depth = cfuncproto( 9402 load_so_libforms(), "fl_set_canvas_depth", 9403 None, [cty.POINTER(FL_OBJECT), cty.c_int], 9404 """void fl_set_canvas_depth(FL_OBJECT * obj, int depth) 9405 """) 9406 idepth = convert_to_int(depth) 9407 keep_elem_refs(pObject, depth, idepth) 9408 _fl_set_canvas_depth(pObject, idepth)
9409 9410
9411 -def fl_set_canvas_attributes(pObject, mask, pXSetWindowAttributes):
9412 """ fl_set_canvas_attributes(pObject, mask, pXSetWindowAttributes) 9413 """ 9414 9415 _fl_set_canvas_attributes = cfuncproto( 9416 load_so_libforms(), "fl_set_canvas_attributes", 9417 None, [cty.POINTER(FL_OBJECT), cty.c_uint, 9418 cty.POINTER(XSetWindowAttributes)], 9419 """void fl_set_canvas_attributes(FL_OBJECT * ob, 9420 unsigned int mask, XSetWindowAttributes * xswa) 9421 """) 9422 uimask = convert_to_uint(mask) 9423 keep_elem_refs(pObject, mask, pXSetWindowAttributes, uimask) 9424 _fl_set_canvas_attributes(pObject, uimask, pXSetWindowAttributes)
9425 9426 9427 FL_HANDLE_CANVAS = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT), Window, 9428 cty.c_int, cty.c_int, cty.POINTER(XEvent), cty.c_void_p) 9429
9430 -def fl_add_canvas_handler(pObject, ev, py_HandleCanvas, udata):
9431 """ fl_add_canvas_handler(pObject, ev, py_HandleCanvas, udata) -> canvas handler 9432 """ 9433 9434 _fl_add_canvas_handler = cfuncproto( 9435 load_so_libforms(), "fl_add_canvas_handler", 9436 FL_HANDLE_CANVAS, [cty.POINTER(FL_OBJECT), cty.c_int, 9437 FL_HANDLE_CANVAS, cty.c_void_p], 9438 """FL_HANDLE_CANVAS fl_add_canvas_handler(FL_OBJECT * ob, int ev, 9439 FL_HANDLE_CANVAS h, void * udata) 9440 """) 9441 iev = convert_to_int(ev) 9442 c_HandleCanvas = FL_HANDLE_CANVAS(py_HandleCanvas) 9443 pudata = cty.cast(udata, cty.c_void_p) 9444 keep_cfunc_refs(c_HandleCanvas, py_HandleCanvas) 9445 keep_elem_refs(pObject, ev, udata, iev, pudata) 9446 retval = _fl_add_canvas_handler(pObject, iev, c_HandleCanvas, pudata) 9447 return retval
9448 9449
9450 -def fl_get_canvas_id(pObject):
9451 """ 9452 fl_get_canvas_id(pObject) -> window 9453 9454 Returns the window ID of the canvas window. 9455 9456 @param pObject : pointer to canvas object 9457 """ 9458 9459 _fl_get_canvas_id = cfuncproto( 9460 load_so_libforms(), "fl_get_canvas_id", 9461 Window, [cty.POINTER(FL_OBJECT)], 9462 """Window fl_get_canvas_id(FL_OBJECT * ob) 9463 """) 9464 keep_elem_refs(pObject) 9465 retval = _fl_get_canvas_id(pObject) 9466 return retval
9467 9468
9469 -def fl_get_canvas_colormap(pObject):
9470 """ fl_get_canvas_colormap(pObject) -> colormap 9471 """ 9472 9473 _fl_get_canvas_colormap = cfuncproto( 9474 load_so_libforms(), "fl_get_canvas_colormap", 9475 Colormap, [cty.POINTER(FL_OBJECT)], 9476 """Colormap fl_get_canvas_colormap(FL_OBJECT * ob) 9477 """) 9478 keep_elem_refs(pObject) 9479 retval = _fl_get_canvas_colormap(pObject) 9480 return retval
9481 9482
9483 -def fl_get_canvas_depth(pObject):
9484 """ fl_get_canvas_depth(pObject) -> depth num. 9485 """ 9486 9487 _fl_get_canvas_depth = cfuncproto( 9488 load_so_libforms(), "fl_get_canvas_depth", 9489 cty.c_int, [cty.POINTER(FL_OBJECT)], 9490 """int fl_get_canvas_depth(FL_OBJECT * obj) 9491 """) 9492 keep_elem_refs(pObject) 9493 retval = _fl_get_canvas_depth(pObject) 9494 return retval
9495 9496
9497 -def fl_remove_canvas_handler(pObject, ev, py_HandleCanvas):
9498 """ 9499 fl_remove_canvas_handler(pObject, ev, py_HandleCanvas) 9500 9501 Remove a particular handler for event ev. If ev is invalid, removes 9502 all handlers and their corresponding event mask. 9503 9504 @param pObject : pointer to canvas object 9505 @param ev : event number 9506 @param py_HandleCanvas : python function for canvas handler 9507 """ 9508 9509 _fl_remove_canvas_handler = cfuncproto( 9510 load_so_libforms(), "fl_remove_canvas_handler", 9511 None, [cty.POINTER(FL_OBJECT), cty.c_int, FL_HANDLE_CANVAS], 9512 """void fl_remove_canvas_handler(FL_OBJECT * ob, int ev, 9513 FL_HANDLE_CANVAS h) 9514 """) 9515 iev = convert_to_int(ev) 9516 c_HandleCanvas = FL_HANDLE_CANVAS(py_HandleCanvas) 9517 keep_cfunc_refs(c_HandleCanvas, py_HandleCanvas) 9518 keep_elem_refs(pObject, ev, iev) 9519 _fl_remove_canvas_handler(pObject, iev, c_HandleCanvas)
9520 9521
9522 -def fl_hide_canvas(pObject):
9523 """ 9524 fl_hide_canvas(pObject) 9525 9526 Hides a canvas object. 9527 9528 @param pObject : pointer to canvas object 9529 """ 9530 9531 _fl_hide_canvas = cfuncproto( 9532 load_so_libforms(), "fl_hide_canvas", 9533 None, [cty.POINTER(FL_OBJECT)], 9534 """void fl_hide_canvas(FL_OBJECT * ob) 9535 """) 9536 keep_elem_refs(pObject) 9537 _fl_hide_canvas(pObject)
9538 9539
9540 -def fl_share_canvas_colormap(pObject, colormap):
9541 """ fl_share_canvas_colormap(pObject, colormap) 9542 """ 9543 9544 _fl_share_canvas_colormap = cfuncproto( 9545 load_so_libforms(), "fl_share_canvas_colormap", 9546 None, [cty.POINTER(FL_OBJECT), Colormap], 9547 """void fl_share_canvas_colormap(FL_OBJECT * ob, Colormap colormap) 9548 """) 9549 ulcolormap = convert_to_ulong(colormap) 9550 keep_elem_refs(pObject, colormap, ulcolormap) 9551 _fl_share_canvas_colormap(pObject, ulcolormap)
9552 9553
9554 -def fl_clear_canvas(pObject):
9555 """ 9556 fl_clear_canvas(pObject) 9557 9558 Clears the canvas to the background color. If no background is 9559 defined use black. 9560 9561 @param pObject : pointer to canvas object 9562 """ 9563 9564 _fl_clear_canvas = cfuncproto( 9565 load_so_libforms(), "fl_clear_canvas", 9566 None, [cty.POINTER(FL_OBJECT)], 9567 """void fl_clear_canvas(FL_OBJECT * ob) 9568 """) 9569 keep_elem_refs(pObject) 9570 _fl_clear_canvas(pObject)
9571 9572 9573 FL_MODIFY_CANVAS_PROP = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT)) 9574
9575 -def fl_modify_canvas_prop(pObject, py_initModifyCanvasProp, \ 9576 py_activateModifyCanvasProp, py_cleanupModifyCanvasProp):
9577 """ 9578 fl_modify_canvas_prop(pObject, py_initModifyCanvasProp, \ 9579 py_activateModifyCanvasProp, py_cleanupModifyCanvasProp) 9580 9581 """ 9582 9583 _fl_modify_canvas_prop = cfuncproto( 9584 load_so_libforms(), "fl_modify_canvas_prop", 9585 None, [cty.POINTER(FL_OBJECT), FL_MODIFY_CANVAS_PROP, 9586 FL_MODIFY_CANVAS_PROP, FL_MODIFY_CANVAS_PROP], 9587 """void fl_modify_canvas_prop(FL_OBJECT * obj, 9588 FL_MODIFY_CANVAS_PROP init, FL_MODIFY_CANVAS_PROP activate, 9589 FL_MODIFY_CANVAS_PROP cleanup) 9590 """) 9591 c_initModifyCanvasProp = FL_MODIFY_CANVAS_PROP(py_initModifyCanvasProp) 9592 c_activateModifyCanvasProp = FL_MODIFY_CANVAS_PROP( \ 9593 py_activateModifyCanvasProp) 9594 c_cleanupModifyCanvasProp = FL_MODIFY_CANVAS_PROP( \ 9595 py_cleanupModifyCanvasProp) 9596 keep_cfunc_refs(c_initModifyCanvasProp, py_initModifyCanvasProp, \ 9597 c_activateModifyCanvasProp, py_activateModifyCanvasProp, \ 9598 c_cleanupModifyCanvasProp, py_cleanupModifyCanvasProp) 9599 keep_elem_refs(pObject) 9600 _fl_modify_canvas_prop(pObject, c_initModifyCanvasProp, 9601 c_activateModifyCanvasProp, c_cleanupModifyCanvasProp)
9602 9603
9604 -def fl_canvas_yield_to_shortcut(pObject, yes):
9605 """ fl_canvas_yield_to_shortcut(pObject, yes) 9606 """ 9607 9608 _fl_canvas_yield_to_shortcut = cfuncproto( 9609 load_so_libforms(), "fl_canvas_yield_to_shortcut", 9610 None, [cty.POINTER(FL_OBJECT), cty.c_int], 9611 """void fl_canvas_yield_to_shortcut(FL_OBJECT * ob, int yes) 9612 """) 9613 iyes = convert_to_int(yes) 9614 keep_elem_refs(pObject, yes, iyes) 9615 _fl_canvas_yield_to_shortcut(pObject, iyes)
9616 9617 9618 9619 ############# 9620 # glcanvas.h 9621 ############# 9622 9623 # This is an attempt to maintain some sort of backwards compatibility 9624 # with old code whilst also getting rid of the old, system-specific 9625 # hack. 9626 9627 # OpenGL canvases 9628
9629 -def fl_create_glcanvas(canvastype, x, y, w, h, label):
9630 """ fl_create_glcanvas(canvastype, x, y, w, h, label) -> pObject 9631 """ 9632 9633 _fl_create_glcanvas = cfuncproto( 9634 load_so_libformsgl(), "fl_create_glcanvas", 9635 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 9636 FL_Coord, STRING], 9637 """FL_OBJECT * fl_create_glcanvas(int type, FL_Coord x, FL_Coord y, 9638 FL_Coord w, FL_Coord h, const char * label) 9639 """) 9640 check_admitted_listvalues(canvastype, CANVASTYPE_list) 9641 icanvastype = convert_to_int(canvastype) 9642 ix = convert_to_FL_Coord(x) 9643 iy = convert_to_FL_Coord(y) 9644 iw = convert_to_FL_Coord(w) 9645 ih = convert_to_FL_Coord(h) 9646 slabel = convert_to_string(label) 9647 keep_elem_refs(canvastype, x, y, w, h, label, icanvastype, ix, iy, 9648 iw, ih, slabel) 9649 retval = _fl_create_glcanvas(icanvastype, ix, iy, iw, ih, slabel) 9650 return retval
9651 9652
9653 -def fl_add_glcanvas(canvastype, x, y, w, h, label):
9654 """ fl_add_glcanvas(canvastype, x, y, w, h, label) -> pObject 9655 """ 9656 9657 _fl_add_glcanvas = cfuncproto( 9658 load_so_libformsgl(), "fl_add_glcanvas", 9659 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 9660 FL_Coord, STRING], 9661 """FL_OBJECT * fl_add_glcanvas(int type, FL_Coord x, FL_Coord y, 9662 FL_Coord w, FL_Coord h, const char * label) 9663 """) 9664 check_admitted_listvalues(canvastype, CANVASTYPE_list) 9665 icanvastype = convert_to_int(canvastype) 9666 ix = convert_to_FL_Coord(x) 9667 iy = convert_to_FL_Coord(y) 9668 iw = convert_to_FL_Coord(w) 9669 ih = convert_to_FL_Coord(h) 9670 slabel = convert_to_string(label) 9671 keep_elem_refs(canvastype, x, y, w, h, label, icanvastype, ix, iy, 9672 iw, ih, slabel) 9673 retval = _fl_add_glcanvas(icanvastype, ix, iy, iw, ih, slabel) 9674 return retval
9675 9676
9677 -def fl_set_glcanvas_defaults(config):
9678 """ fl_set_glcanvas_defaults(config): 9679 """ 9680 9681 _fl_set_glcanvas_defaults = cfuncproto( 9682 load_so_libformsgl(), "fl_set_glcanvas_defaults", 9683 None, [cty.POINTER(cty.c_int)], 9684 """void fl_set_glcanvas_defaults(const int * config): 9685 """) 9686 #iconfig = convert_to_int(config) 9687 keep_elem_refs(config) #, iconfig) 9688 _fl_set_glcanvas_defaults(config)
9689 9690
9691 -def fl_get_glcanvas_defaults(config):
9692 """ fl_get_glcanvas_defaults(config): 9693 """ 9694 9695 _fl_get_glcanvas_defaults = cfuncproto( 9696 load_so_libformsgl(), "fl_get_glcanvas_defaults", 9697 None, [cty.c_int], 9698 """void fl_get_glcanvas_defaults(int config[ ]): 9699 """) 9700 iconfig = convert_to_int(config) 9701 keep_elem_refs(config, iconfig) 9702 _fl_get_glcanvas_defaults(iconfig)
9703 9704
9705 -def fl_set_glcanvas_attributes(pObject, config):
9706 """ fl_set_glcanvas_attributes(pObject, config) 9707 """ 9708 9709 _fl_set_glcanvas_attributes = cfuncproto( 9710 load_so_libformsgl(), "fl_set_glcanvas_attributes", 9711 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int)], 9712 """void fl_set_glcanvas_attributes(FL_OBJECT * ob, 9713 const int * config) 9714 """) 9715 keep_elem_refs(pObject, config) 9716 _fl_set_glcanvas_attributes(pObject, config)
9717 9718
9719 -def fl_get_glcanvas_attributes(pObject, attributes):
9720 """ fl_get_glcanvas_attributes(pObject, attributes) 9721 """ 9722 9723 _fl_get_glcanvas_attributes = cfuncproto( 9724 load_so_libformsgl(), "fl_get_glcanvas_attributes", 9725 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int)], 9726 """void fl_get_glcanvas_attributes(FL_OBJECT * ob, 9727 int * attributes) 9728 """) 9729 keep_elem_refs(pObject, attributes) 9730 _fl_get_glcanvas_attributes(pObject, attributes)
9731 9732
9733 -def fl_set_glcanvas_direct(pObject, direct):
9734 """ fl_set_glcanvas_direct(pObject, direct) 9735 """ 9736 9737 _fl_set_glcanvas_direct = cfuncproto( 9738 load_so_libformsgl(), "fl_set_glcanvas_direct", 9739 None, [cty.POINTER(FL_OBJECT), cty.c_int], 9740 """void fl_set_glcanvas_direct(FL_OBJECT * ob, int direct) 9741 """) 9742 idirect = convert_to_int(direct) 9743 keep_elem_refs(pObject, direct, idirect) 9744 _fl_set_glcanvas_direct(pObject, idirect)
9745 9746
9747 -def fl_activate_glcanvas(pObject):
9748 """ fl_activate_glcanvas(pObject) 9749 """ 9750 9751 _fl_activate_glcanvas = cfuncproto( 9752 load_so_libformsgl(), "fl_activate_glcanvas", 9753 None, [cty.POINTER(FL_OBJECT)], 9754 """void fl_activate_glcanvas(FL_OBJECT * ob) 9755 """) 9756 keep_elem_refs(pObject) 9757 _fl_activate_glcanvas(pObject)
9758 9759
9760 -def fl_get_glcanvas_xvisualinfo(pObject):
9761 """ fl_get_glcanvas_xvisualinfo(pObject) -> xvisualinfo class 9762 """ 9763 9764 _fl_get_glcanvas_xvisualinfo = cfuncproto( 9765 load_so_libformsgl(), "fl_get_glcanvas_xvisualinfo", 9766 cty.POINTER(XVisualInfo), [cty.POINTER(FL_OBJECT)], 9767 """)XVisualInfo * fl_get_glcanvas_xvisualinfo(FL_OBJECT * ob) 9768 """) 9769 keep_elem_refs(pObject) 9770 retval = _fl_get_glcanvas_xvisualinfo(pObject) 9771 return retval
9772 9773
9774 -def fl_get_glcanvas_context(pObject):
9775 """ fl_get_glcanvas_context(pObject) -> glxcontext class 9776 """ 9777 9778 _fl_get_glcanvas_context = cfuncproto( 9779 load_so_libformsgl(), "fl_get_glcanvas_context", 9780 GLXContext, [cty.POINTER(FL_OBJECT)], 9781 """)GLXContext fl_get_glcanvas_context(FL_OBJECT * ob) 9782 """) 9783 keep_elem_refs(pObject) 9784 retval = _fl_get_glcanvas_context(pObject) 9785 return retval
9786 9787
9788 -def fl_glwincreate(config, pGLXContext, w, h):
9789 """ fl_glwincreate(config, pGLXContext, w, h) -> window 9790 """ 9791 9792 _fl_glwincreate = cfuncproto( 9793 load_so_libformsgl(), "fl_glwincreate", 9794 Window, [cty.POINTER(cty.c_int), cty.POINTER(GLXContext), 9795 cty.c_int, cty.c_int], 9796 """Window fl_glwincreate(int * config, GLXContext * context, 9797 int w, int h) 9798 """) 9799 iw = convert_to_int(w) 9800 ih = convert_to_int(h) 9801 keep_elem_refs(config, pGLXContext, w, h, iw, ih) 9802 retval = _fl_glwincreate(config, pGLXContext, iw, ih) 9803 return retval
9804 9805
9806 -def fl_glwinopen(config, pGLXContext, w, h):
9807 """ fl_glwinopen(config, pGLXContext, w, h) -> window 9808 """ 9809 9810 _fl_glwinopen = cfuncproto( 9811 load_so_libformsgl(), "fl_glwinopen", 9812 Window, [cty.POINTER(cty.c_int), cty.POINTER(GLXContext), 9813 cty.c_int, cty.c_int], 9814 """Window fl_glwinopen(int * config, GLXContext * context, 9815 int w, int h 9816 """) 9817 iw = convert_to_int(w) 9818 ih = convert_to_int(h) 9819 keep_elem_refs(config, pGLXContext, w, h, iw, ih) 9820 retval = _fl_glwinopen(config, pGLXContext, iw, ih) 9821 return retval
9822 9823 9824 9825 ############################# 9826 # forms.h (chart.h) 9827 # Object Class: Chart 9828 ############################# 9829 9830 # Routines 9831
9832 -def fl_create_chart(charttype, x, y, w, h, label):
9833 """ 9834 fl_create_chart(charttype, x, y, w, h, label) -> pObject 9835 9836 Creates a chart object. 9837 9838 @param charttype : type of chart object to be created 9839 @param x : horizontal position of chart (upper-left corner) 9840 @param x : vertical position of chart (upper-left corner) 9841 @param w : width of chart in pixels 9842 @param h : height of chart in pixels 9843 @param label : text label of chart 9844 """ 9845 9846 _fl_create_chart = cfuncproto( 9847 load_so_libforms(), "fl_create_chart", 9848 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 9849 FL_Coord, STRING], 9850 """FL_OBJECT * fl_create_chart(int type, FL_Coord x, FL_Coord y, 9851 FL_Coord w, FL_Coord h, const char * label) 9852 """) 9853 check_admitted_listvalues(charttype, CHARTTYPE_list) 9854 icharttype = convert_to_int(charttype) 9855 ix = convert_to_FL_Coord(x) 9856 iy = convert_to_FL_Coord(y) 9857 iw = convert_to_FL_Coord(w) 9858 ih = convert_to_FL_Coord(h) 9859 slabel = convert_to_string(label) 9860 keep_elem_refs(charttype, x, y, w, h, label, icharttype, ix, iy, 9861 iw, ih, slabel) 9862 retval = _fl_create_chart(icharttype, ix, iy, iw, ih, slabel) 9863 return retval
9864 9865
9866 -def fl_add_chart(charttype, x, y, w, h, label):
9867 """ 9868 fl_add_chart(charttype, x, y, w, h, label) -> pObject 9869 9870 Adds a chart object. 9871 9872 @param charttype : type of chart object to be created 9873 @param x : horizontal position of chart (upper-left corner) 9874 @param x : vertical position of chart (upper-left corner) 9875 @param w : width of chart in pixels 9876 @param h : height of chart in pixels 9877 @param label : text label of chart 9878 """ 9879 9880 _fl_add_chart = cfuncproto( 9881 load_so_libforms(), "fl_add_chart", 9882 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 9883 FL_Coord, STRING], 9884 """FL_OBJECT * fl_add_chart(int type, FL_Coord x, FL_Coord y, 9885 FL_Coord w, FL_Coord h, const char * label) 9886 """) 9887 check_admitted_listvalues(charttype, CHARTTYPE_list) 9888 icharttype = convert_to_int(charttype) 9889 ix = convert_to_FL_Coord(x) 9890 iy = convert_to_FL_Coord(y) 9891 iw = convert_to_FL_Coord(w) 9892 ih = convert_to_FL_Coord(h) 9893 slabel = convert_to_string(label) 9894 keep_elem_refs(charttype, x, y, w, h, label, icharttype, ix, iy, 9895 iw, ih, slabel) 9896 retval = _fl_add_chart(icharttype, ix, iy, iw, ih, slabel) 9897 return retval
9898 9899
9900 -def fl_clear_chart(pObject):
9901 """ fl_clear_chart(pObject) 9902 9903 Clears the contents of a chart. 9904 9905 @param pObject : pointer to chart object 9906 """ 9907 9908 _fl_clear_chart = cfuncproto( 9909 load_so_libforms(), "fl_clear_chart", 9910 None, [cty.POINTER(FL_OBJECT)], 9911 """void fl_clear_chart(FL_OBJECT * ob) 9912 """) 9913 keep_elem_refs(pObject) 9914 _fl_clear_chart(pObject)
9915 9916
9917 -def fl_add_chart_value(pObject, val, label, col):
9918 """ 9919 fl_add_chart_value(pObject, val, label, col) 9920 9921 Adds an item to the chart. 9922 9923 @param pObject : pointer to chart object 9924 @param val : value of chart item 9925 @param label : text label of chart object 9926 @param col : ? 9927 """ 9928 9929 _fl_add_chart_value = cfuncproto( 9930 load_so_libforms(), "fl_add_chart_value", 9931 None, [cty.POINTER(FL_OBJECT), cty.c_double, STRING, cty.c_int], 9932 """void fl_add_chart_value(FL_OBJECT * ob, double val, 9933 const char * str, int col) 9934 """) 9935 fval = convert_to_double(val) 9936 slabel = convert_to_string(label) 9937 icol = convert_to_int(col) 9938 keep_elem_refs(pObject, val, label, col, fval, slabel, icol) 9939 _fl_add_chart_value(pObject, fval, slabel, icol)
9940 9941
9942 -def fl_insert_chart_value(pObject, indx, val, label, col):
9943 """ 9944 fl_insert_chart_value(pObject, indx, val, label, col) 9945 9946 Inserts an item before indx to the chart. 9947 9948 @param pObject : pointer to chart object 9949 @param indx : index position of previous item 9950 @param val : value of chart item 9951 @param label : text label of chart 9952 @param col : ? 9953 """ 9954 9955 _fl_insert_chart_value = cfuncproto( 9956 load_so_libforms(), "fl_insert_chart_value", 9957 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_double, STRING, 9958 cty.c_int], 9959 """void fl_insert_chart_value(FL_OBJECT * ob, int indx, 9960 double val, const char * str, int col) 9961 """) 9962 iindx = convert_to_int(indx) 9963 fval = convert_to_double(val) 9964 slabel = convert_to_string(label) 9965 icol = convert_to_int(col) 9966 keep_elem_refs(pObject, indx, val, label, col, iindx, fval, 9967 slabel, icol) 9968 _fl_insert_chart_value(pObject, iindx, fval, slabel, icol)
9969 9970
9971 -def fl_replace_chart_value(pObject, indx, val, label, col):
9972 """ 9973 fl_replace_chart_value(pObject, indx, val, label, col) 9974 9975 Replaces value in the chart. 9976 9977 @param pObject : pointer to chart object 9978 @param indx : index position of item to be replaced 9979 @param val : value of chart item 9980 @param label : text label of chart 9981 @param col : ? 9982 """ 9983 9984 _fl_replace_chart_value = cfuncproto( 9985 load_so_libforms(), "fl_replace_chart_value", 9986 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_double, STRING, 9987 cty.c_int], 9988 """void fl_replace_chart_value(FL_OBJECT * ob, int indx, 9989 double val, const char * str, int col) 9990 """) 9991 iindx = convert_to_int(indx) 9992 fval = convert_to_double(val) 9993 slabel = convert_to_string(label) 9994 icol = convert_to_int(col) 9995 keep_elem_refs(pObject, indx, val, label, col, iindx, fval, 9996 slabel, icol) 9997 _fl_replace_chart_value(pObject, iindx, fval, slabel, icol)
9998 9999
10000 -def fl_set_chart_bounds(pObject, minbound, maxbound):
10001 """ 10002 fl_set_chart_bounds(pObject, minbound, maxbound) 10003 10004 Sets the boundaries/limits for values of a chart object. 10005 10006 @param pObject : pointer to chart object 10007 @param minbound : minimum bounds to be set 10008 @param maxbound : maximum bounds to be set 10009 """ 10010 10011 _fl_set_chart_bounds = cfuncproto( 10012 load_so_libforms(), "fl_set_chart_bounds", 10013 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 10014 """void fl_set_chart_bounds(FL_OBJECT * ob, double min, 10015 double max) 10016 """) 10017 fminbound = convert_to_double(minbound) 10018 fmaxbound = convert_to_double(maxbound) 10019 keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 10020 _fl_set_chart_bounds(pObject, fminbound, fmaxbound)
10021 10022 10023 #def fl_get_chart_bounds(pObject, minbound, maxbound) *API change*
10024 -def fl_get_chart_bounds(pObject):
10025 """ 10026 fl_get_chart_bounds(pObject) -> minbound, maxbound 10027 10028 Returns the boundaries/limits set for values of a chart object. 10029 10030 @param pObject : pointer to chart object 10031 """ 10032 10033 _fl_get_chart_bounds = cfuncproto( 10034 load_so_libforms(), "fl_get_chart_bounds", 10035 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 10036 cty.POINTER(cty.c_double)], 10037 """void fl_get_chart_bounds(FL_OBJECT * ob, double * min, 10038 double * max) 10039 """) 10040 minbound, pminbound = make_double_and_pointer() 10041 maxbound, pmaxbound = make_double_and_pointer() 10042 keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 10043 _fl_get_chart_bounds(pObject, pminbound, pmaxbound) 10044 return minbound, maxbound
10045 10046
10047 -def fl_set_chart_maxnumb(pObject, maxnum):
10048 """ 10049 fl_set_chart_maxnumb(pObject, maxnum) 10050 10051 Sets the maximum number of values displayed in the chart. 10052 10053 @param pObject : pointer to chart object 10054 @param maxnum : maximum number of values to display 10055 """ 10056 10057 _fl_set_chart_maxnumb = cfuncproto( 10058 load_so_libforms(), "fl_set_chart_maxnumb", 10059 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10060 """void fl_set_chart_maxnumb(FL_OBJECT * ob, int maxnumb) 10061 """) 10062 imaxnumb = convert_to_int(maxnum) 10063 keep_elem_refs(pObject, maxnum, imaxnum) 10064 _fl_set_chart_maxnumb(pObject, imaxnum)
10065 10066
10067 -def fl_set_chart_autosize(pObject, autosize):
10068 """ 10069 fl_set_chart_autosize(pObject, autosize) 10070 10071 Sets whether the chart should autosize along the x-axis. 10072 10073 @param pObject : pointer to chart object 10074 @param autosize : autosize flag is enabled/disabled (1|0) 10075 """ 10076 10077 _fl_set_chart_autosize = cfuncproto( 10078 load_so_libforms(), "fl_set_chart_autosize", 10079 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10080 """void fl_set_chart_autosize(FL_OBJECT * ob, int autosize) 10081 """) 10082 iautosize = convert_to_int(autosize) 10083 keep_elem_refs(pObject, autosize, iautosize) 10084 _fl_set_chart_autosize(pObject, iautosize)
10085 10086
10087 -def fl_set_chart_lstyle(pObject, lstyle):
10088 """ fl_set_chart_lstyle(pObject, lstyle) 10089 """ 10090 10091 _fl_set_chart_lstyle = cfuncproto( 10092 load_so_libforms(), "fl_set_chart_lstyle", 10093 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10094 """void fl_set_chart_lstyle(FL_OBJECT * ob, int lstyle) 10095 """) 10096 ilstyle = convert_to_int(lstyle) 10097 keep_elem_refs(pObject, lstyle, ilstyle) 10098 _fl_set_chart_lstyle(pObject, ilstyle)
10099 10100
10101 -def fl_set_chart_lsize(pObject, lsize):
10102 """ fl_set_chart_lsize(pObject, lsize) 10103 """ 10104 10105 _fl_set_chart_lsize = cfuncproto( 10106 load_so_libforms(), "fl_set_chart_lsize", 10107 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10108 """void fl_set_chart_lsize(FL_OBJECT * ob, int lsize) 10109 """) 10110 ilsize = convert_to_int(lsize) 10111 keep_elem_refs(pObject, lsize, ilsize) 10112 _fl_set_chart_lsize(pObject, ilsize)
10113 10114
10115 -def fl_set_chart_lcolor(pObject, colr):
10116 """ fl_set_chart_lcolor(pObject, colr) 10117 """ 10118 10119 _fl_set_chart_lcolor = cfuncproto( 10120 load_so_libforms(), "fl_set_chart_lcolor", 10121 None, [cty.POINTER(FL_OBJECT), FL_COLOR], 10122 """void fl_set_chart_lcolor(FL_OBJECT * ob, FL_COLOR lcol) 10123 """) 10124 ulcolr = convert_to_FL_COLOR(colr) 10125 keep_elem_refs(pObject, colr, ulcolr) 10126 _fl_set_chart_lcolor(pObject, ulcolr)
10127 10128
10129 -def fl_set_chart_baseline(pObject, yesno):
10130 """ fl_set_chart_baseline(pObject, yesno) 10131 """ 10132 10133 _fl_set_chart_baseline = cfuncproto( 10134 load_so_libforms(), "fl_set_chart_baseline", 10135 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10136 """void fl_set_chart_baseline(FL_OBJECT * ob, int iYesNo) 10137 """) 10138 iyesno = convert_to_int(yesno) 10139 keep_elem_refs(pObject, yesno, iyesno) 10140 _fl_set_chart_baseline(pObject, iyesno)
10141 10142 10143 fl_set_chart_lcol = fl_set_chart_lcolor 10144 10145 10146 10147 ##################### 10148 # forms.h (choice.h) 10149 ##################### 10150 10151 # Routines 10152
10153 -def fl_create_choice(choicetype, x, y, w, h, label):
10154 """ 10155 fl_create_choice(choicetype, x, y, w, h, label) -> pObject 10156 10157 Creates a choice object. 10158 10159 @param choicetype : type of choice object to be created 10160 @param x : horizontal position of choice (upper-left corner) 10161 @param x : vertical position of choice (upper-left corner) 10162 @param w : width of choice in pixels 10163 @param h : height of choice in pixels 10164 @param label : text label of choice 10165 """ 10166 10167 _fl_create_choice = cfuncproto( 10168 load_so_libforms(), "fl_create_choice", 10169 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 10170 FL_Coord, STRING], 10171 """FL_OBJECT * fl_create_choice(int type, FL_Coord x, FL_Coord y, 10172 FL_Coord w, FL_Coord h, const char * label) 10173 """) 10174 check_admitted_listvalues(choicetype, CHOICETYPE_list) 10175 ichoicetype = convert_to_int(choicetype) 10176 ix = convert_to_FL_Coord(x) 10177 iy = convert_to_FL_Coord(y) 10178 iw = convert_to_FL_Coord(w) 10179 ih = convert_to_FL_Coord(h) 10180 slabel = convert_to_string(label) 10181 keep_elem_refs(choicetype, x, y, w, h, label, ichoicetype, ix, iy, 10182 iw, ih, slabel) 10183 retval = _fl_create_choice(ichoicetype, ix, iy, iw, ih, slabel) 10184 return retval
10185 10186
10187 -def fl_add_choice(choicetype, x, y, w, h, label):
10188 """ 10189 fl_add_choice(choicetype, x, y, w, h, label) -> pObject 10190 10191 Adds a choice object. 10192 10193 @param choicetype : type of choice object to be added 10194 @param x : horizontal position of choice (upper-left corner) 10195 @param x : vertical position of choice (upper-left corner) 10196 @param w : width of choice in pixels 10197 @param h : height of choice in pixels 10198 @param label : text label of choice 10199 """ 10200 10201 _fl_add_choice = cfuncproto( 10202 load_so_libforms(), "fl_add_choice", 10203 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 10204 FL_Coord, STRING], 10205 """FL_OBJECT * fl_add_choice(int type, FL_Coord x, FL_Coord y, 10206 FL_Coord w, FL_Coord h, const char * label) DEPRECATED 10207 """) 10208 check_admitted_listvalues(choicetype, CHOICETYPE_list) 10209 ichoicetype = convert_to_int(choicetype) 10210 ix = convert_to_FL_Coord(x) 10211 iy = convert_to_FL_Coord(y) 10212 iw = convert_to_FL_Coord(w) 10213 ih = convert_to_FL_Coord(h) 10214 slabel = convert_to_string(label) 10215 keep_elem_refs(choicetype, x, y, w, h, label, ichoicetype, ix, iy, 10216 iw, ih, slabel) 10217 retval = _fl_add_choice(ichoicetype, ix, iy, iw, ih, slabel) 10218 return retval
10219 10220
10221 -def fl_clear_choice(pObject):
10222 """ 10223 fl_clear_choice(pObject) 10224 10225 Clears the choice object. 10226 10227 @param pObject : pointer to chioce object 10228 """ 10229 10230 _fl_clear_choice = cfuncproto( 10231 load_so_libforms(), "fl_clear_choice", 10232 None, [cty.POINTER(FL_OBJECT)], 10233 """void fl_clear_choice(FL_OBJECT * ob) DEPRECATED 10234 """) 10235 keep_elem_refs(pObject) 10236 _fl_clear_choice(pObject)
10237 10238
10239 -def fl_addto_choice(pObject, choicetxt):
10240 """ 10241 fl_addto_choice(pObject, choicetxt) -> num. 10242 10243 Adds a single or multiple (delimited by '|') item(s) to a choice. 10244 10245 @param pObject : pointer to choice object 10246 @param choicetxt : text of item(s) to be added 10247 """ 10248 10249 _fl_addto_choice = cfuncproto( 10250 load_so_libforms(), "fl_addto_choice", 10251 cty.c_int, [cty.POINTER(FL_OBJECT), STRING], 10252 """int fl_addto_choice(FL_OBJECT * ob, const char * str) DEPRECATED 10253 """) 10254 warn_deprecated_function() 10255 schoicetxt = convert_to_string(choicetxt) 10256 keep_elem_refs(pObject, choicetxt, schoicetxt) 10257 retval = _fl_addto_choice(pObject, schoicetxt) 10258 return retval
10259 10260
10261 -def fl_replace_choice(pObject, itemnum, choicetxt):
10262 """ 10263 fl_replace_choice(pObject, itemnum, choicetxt) 10264 10265 Replaces a line to the choice item. 10266 10267 @param pObject : pointer to choice object 10268 @param itemnum : item number to be replaced 10269 @param choicetxt : text of item to replace 10270 """ 10271 10272 _fl_replace_choice = cfuncproto( 10273 load_so_libforms(), "fl_replace_choice", 10274 None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 10275 """void fl_replace_choice(FL_OBJECT * ob, int numb, 10276 const char * str) DEPRECATED 10277 """) 10278 iitemnum = convert_to_int(itemnum) 10279 schoicetxt = convert_to_string(choicetxt) 10280 keep_elem_refs(pObject, itemnum, choicetxt, iitemnum, schoicetxt) 10281 _fl_replace_choice(pObject, iitemnum, schoicetxt)
10282 10283
10284 -def fl_delete_choice(pObject, itemnum):
10285 """ 10286 fl_delete_choice(pObject, itemnum) 10287 10288 Removes a line from the choice item. 10289 10290 @param pObject : pointer to choice object 10291 @param itemnum : item number 10292 """ 10293 10294 _fl_delete_choice = cfuncproto( 10295 load_so_libforms(), "fl_delete_choice", 10296 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10297 """void fl_delete_choice(FL_OBJECT * ob, int numb) DEPRECATED 10298 """) 10299 iitemnum = convert_to_int(itemnum) 10300 keep_elem_refs(pObject, itemnum, iitemnum) 10301 _fl_delete_choice(pObject, iitemnum)
10302 10303
10304 -def fl_set_choice(pObject, choice):
10305 """ 10306 fl_set_choice(pObject, choice) 10307 10308 Sets the number of the choice. 10309 10310 @param pObject : pointer to choice object 10311 @param choice : choice number 10312 """ 10313 10314 _fl_set_choice = cfuncproto( 10315 load_so_libforms(), "fl_set_choice", 10316 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10317 """void fl_set_choice(FL_OBJECT * ob, int choice) DEPRECATED 10318 """) 10319 ichoice = convert_to_int(choice) 10320 keep_elem_refs(pObject, choice, ichoice) 10321 _fl_set_choice(pObject, ichoice)
10322 10323
10324 -def fl_set_choice_text(pObject, choicetxt):
10325 """ 10326 fl_set_choice_text(pObject, choicetxt) 10327 10328 Sets the choice using choice text. 10329 10330 @param pObject : pointer to choice object 10331 @param choicetxt : text of choice 10332 """ 10333 10334 _fl_set_choice_text = cfuncproto( 10335 load_so_libforms(), "fl_set_choice_text", 10336 None, [cty.POINTER(FL_OBJECT), STRING], 10337 """void fl_set_choice_text(FL_OBJECT * ob, const char * txt) DEPRECATED 10338 """) 10339 schoicetxt = convert_to_string(choicetxt) 10340 keep_elem_refs(pObject, choicetxt, schoicetxt) 10341 _fl_set_choice_text(pObject, schoicetxt)
10342 10343
10344 -def fl_get_choice(pObject):
10345 """ 10346 fl_get_choice(pObject) -> num. 10347 10348 Returns the number of the choice. 10349 10350 @param pObject : pointer to choice object 10351 """ 10352 10353 _fl_get_choice = cfuncproto( 10354 load_so_libforms(), "fl_get_choice", 10355 cty.c_int, [cty.POINTER(FL_OBJECT)], 10356 """int fl_get_choice(FL_OBJECT * ob) DEPRECATED 10357 """) 10358 keep_elem_refs(pObject) 10359 retval = _fl_get_choice(pObject) 10360 return retval
10361 10362
10363 -def fl_get_choice_item_text(pObject, n):
10364 """ fl_get_choice_item_text(pObject, n) -> text string 10365 """ 10366 10367 _fl_get_choice_item_text = cfuncproto( 10368 load_so_libforms(), "fl_get_choice_item_text", 10369 STRING, [cty.POINTER(FL_OBJECT), cty.c_int], 10370 """const char * fl_get_choice_item_text(FL_OBJECT * ob, int n) DEPRECATED 10371 """) 10372 inum = convert_to_int(n) 10373 keep_elem_refs(pObject, n, inum) 10374 retval = _fl_get_choice_item_text(pObject, inum) 10375 return retval
10376 10377
10378 -def fl_get_choice_maxitems(pObject):
10379 """ fl_get_choice_maxitems(pObject) -> items num. 10380 """ 10381 10382 _fl_get_choice_maxitems = cfuncproto( 10383 load_so_libforms(), "fl_get_choice_maxitems", 10384 cty.c_int, [cty.POINTER(FL_OBJECT)], 10385 """int fl_get_choice_maxitems(FL_OBJECT * ob) DEPRECATED 10386 """) 10387 keep_elem_refs(pObject) 10388 retval = _fl_get_choice_maxitems(pObject) 10389 return retval
10390 10391
10392 -def fl_get_choice_text(pObject):
10393 """ 10394 fl_get_choice_text(pObject) -> text string 10395 10396 Returns the text of the choice. 10397 10398 @param pObject : pointer to choice object 10399 """ 10400 10401 _fl_get_choice_text = cfuncproto( 10402 load_so_libforms(), "fl_get_choice_text", 10403 STRING, [cty.POINTER(FL_OBJECT)], 10404 """const char * fl_get_choice_text(FL_OBJECT * ob) DEPRECATED 10405 """) 10406 keep_elem_refs(pObject) 10407 retval = _fl_get_choice_text(pObject) 10408 return retval
10409 10410
10411 -def fl_set_choice_fontsize(pObject, size):
10412 """ 10413 fl_set_choice_fontsize(pObject, size) 10414 10415 Sets the font size inside the choice. 10416 10417 @param pObject : pointer to choice object 10418 @param size : font size of choice to be set 10419 """ 10420 10421 _fl_set_choice_fontsize = cfuncproto( 10422 load_so_libforms(), "fl_set_choice_fontsize", 10423 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10424 """void fl_set_choice_fontsize(FL_OBJECT * ob, int size) 10425 """) 10426 isize = convert_to_int(size) 10427 keep_elem_refs(pObject, size, isize) 10428 _fl_set_choice_fontsize(pObject, isize)
10429 10430
10431 -def fl_set_choice_fontstyle(pObject, style):
10432 """ 10433 fl_set_choice_fontstyle(pObject, style) 10434 10435 Sets the font style inside the choice. 10436 10437 @param pObject : pointer to choice object 10438 @param style : font style of choice to be set 10439 """ 10440 10441 _fl_set_choice_fontstyle = cfuncproto( 10442 load_so_libforms(), "fl_set_choice_fontstyle", 10443 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10444 """void fl_set_choice_fontstyle(FL_OBJECT * ob, int style) 10445 """) 10446 istyle = convert_to_int(style) 10447 keep_elem_refs(pObject, style, istyle) 10448 _fl_set_choice_fontstyle(pObject, istyle)
10449 10450
10451 -def fl_set_choice_align(pObject, align):
10452 """ 10453 fl_set_choice_align(pObject, align) 10454 10455 Sets alignment of text inside the choice. 10456 10457 @param pObject : pointer to choice object 10458 @param align : alignment of choice text to be set 10459 """ 10460 10461 _fl_set_choice_align = cfuncproto( 10462 load_so_libforms(), "fl_set_choice_align", 10463 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10464 """void fl_set_choice_align(FL_OBJECT * ob, int align) 10465 """) 10466 ialign = convert_to_int(align) 10467 keep_elem_refs(pObject, align, ialign) 10468 _fl_set_choice_align(pObject, ialign)
10469 10470
10471 -def fl_get_choice_item_mode(pObject, item):
10472 """ fl_get_choice_item_mode(pObject, item) -> mode num. 10473 """ 10474 10475 _fl_get_choice_item_mode = cfuncproto( 10476 load_so_libforms(), "fl_get_choice_item_mode", 10477 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 10478 """int fl_get_choice_item_mode(FL_OBJECT * ob, int item) DEPRECATED 10479 """) 10480 iitem = convert_to_int(item) 10481 keep_elem_refs(pObject, item, iitem) 10482 retval = _fl_get_choice_item_mode(pObject, iitem) 10483 return retval
10484 10485
10486 -def fl_set_choice_item_mode(pObject, itemnum, mode):
10487 """ 10488 fl_set_choice_item_mode(pObject, itemnum, mode) 10489 10490 Sets the mode of an item in a choice object. 10491 10492 @param pObject : pointer to choice object 10493 @param itemnum : item number whose mode is to be set 10494 @param mode : mode of item 10495 """ 10496 10497 _fl_set_choice_item_mode = cfuncproto( 10498 load_so_libforms(), "fl_set_choice_item_mode", 10499 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_uint], 10500 """void fl_set_choice_item_mode(FL_OBJECT * ob, int item, 10501 unsigned int mode) 10502 """) 10503 iitemnum = convert_to_int(itemnum) 10504 uimode = convert_to_uint(mode) 10505 keep_elem_refs(pObject, itemnum, mode, iitemnum, uimode) 10506 _fl_set_choice_item_mode(pObject, iitemnum, uimode)
10507 10508
10509 -def fl_set_choice_item_shortcut(pObject, item, sctext):
10510 """ fl_set_choice_item_shortcut(pObject, item, sstext) 10511 """ 10512 10513 _fl_set_choice_item_shortcut = cfuncproto( 10514 load_so_libforms(), "fl_set_choice_item_shortcut", 10515 None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 10516 """void fl_set_choice_item_shortcut(FL_OBJECT * ob, int item, 10517 const char * sc) 10518 """) 10519 iitem = convert_to_int(item) 10520 ssctext = convert_to_string(sctext) 10521 keep_elem_refs(pObject, item, sctext, iitem, ssctext) 10522 _fl_set_choice_item_shortcut(pObject, iitem, ssctext)
10523 10524
10525 -def fl_set_choice_entries(pObject, pPopupEntry):
10526 """ fl_set_choice_entries(pObject, pPopupEntry) -> num. 10527 """ 10528 10529 _fl_set_choice_entries = cfuncproto( 10530 load_so_libforms(), "fl_set_choice_entries", 10531 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_PUP_ENTRY)], 10532 """int fl_set_choice_entries(FL_OBJECT * ob, FL_PUP_ENTRY * ent) DEPRECATED 10533 """) 10534 keep_elem_refs(pObject, pPopupEntry) 10535 retval = _fl_set_choice_entries(pObject, pPopupEntry) 10536 return retval
10537 10538
10539 -def fl_set_choice_notitle(pObject, n):
10540 """ fl_set_choice_notitle(pObject, n) -> num. 10541 """ 10542 10543 _fl_set_choice_notitle = cfuncproto( 10544 load_so_libforms(), "fl_set_choice_notitle", 10545 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 10546 """int fl_set_choice_notitle(FL_OBJECT * ob, int n) 10547 """) 10548 inum = convert_to_int(n) 10549 keep_elem_refs(pObject, n, inum) 10550 retval = _fl_set_choice_notitle(pObject, inum) 10551 return retval
10552 10553 10554 10555 ################################# 10556 # forms.h (clipbd.h) 10557 # prototypes for clipboard stuff 10558 ################################# 10559 10560 FL_LOSE_SELECTION_CB = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT), 10561 cty.c_long) 10562 FL_LOSE_SELECTION_CALLBACK = FL_LOSE_SELECTION_CB 10563
10564 -def fl_stuff_clipboard(pObject, clipbdtype, data, size, py_LoseSelectionCb):
10565 """ fl_stuff_clipboard(pObject, clipbdtype, data, size, py_LoseSelectionCb) -> num. 10566 """ 10567 10568 _fl_stuff_clipboard = cfuncproto( 10569 load_so_libforms(), "fl_stuff_clipboard", 10570 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_long, cty.c_void_p, 10571 cty.c_long, FL_LOSE_SELECTION_CB], 10572 """int fl_stuff_clipboard(FL_OBJECT * ob, long int type, 10573 const char * data, long int size, 10574 FL_LOSE_SELECTION_CB lose_callback) 10575 """) 10576 lclipbdtype = convert_to_long(clipbdtype) # type is not used 10577 lsize = convert_to_long(size) 10578 c_LoseSelectionCb = FL_LOSE_SELECTION_CB(py_LoseSelectionCb) 10579 keep_cfunc_refs(c_LoseSelectionCb, py_LoseSelectionCb) 10580 keep_elem_refs(pObject, clipbdtype, data, size, lclipbdtype, lsize) 10581 retval = _fl_stuff_clipboard(pObject, lclipbdtype, data, lsize, 10582 c_LoseSelectionCb) 10583 return retval
10584 10585 10586 FL_SELECTION_CB = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT), 10587 cty.c_long, cty.c_void_p, cty.c_long) 10588 FL_SELECTION_CALLBACK = FL_SELECTION_CB 10589
10590 -def fl_request_clipboard(pObject, clipbdtype, py_SelectionCb):
10591 """ fl_request_clipboard(pObject, clipbdtype, py_SelectionCb) -> num. 10592 """ 10593 10594 _fl_request_clipboard = cfuncproto( 10595 load_so_libforms(), "fl_request_clipboard", 10596 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_long, FL_SELECTION_CB], 10597 """int fl_request_clipboard(FL_OBJECT * ob, long int type, 10598 FL_SELECTION_CB got_it_callback) 10599 """) 10600 lclipbdtype = convert_to_long(clipbdtype) # type is not used 10601 c_SelectionCb = FL_SELECTION_CB(py_SelectionCb) 10602 keep_cfunc_refs(c_SelectionCb, py_SelectionCb) 10603 keep_elem_refs(pObject, clipbdtype, lclipbdtype) 10604 retval = _fl_request_clipboard(pObject, lclipbdtype, c_SelectionCb) 10605 return retval
10606 10607 10608 10609 ################################# 10610 # forms.h (clock.h) 10611 ################################# 10612 10613
10614 -def fl_create_clock(clocktype, x, y, w, h, label):
10615 """ 10616 fl_create_clock(clocktype, x, y, w, h, label) -> pObject 10617 10618 Creates a clock object. 10619 10620 @param clocktype : type of clock object to be created 10621 @param x : horizontal position of clock (upper-left corner) 10622 @param x : vertical position of clock (upper-left corner) 10623 @param w : width of clock in pixels 10624 @param h : height of clock in pixels 10625 @param label : text label of clock 10626 """ 10627 10628 _fl_create_clock = cfuncproto( 10629 load_so_libforms(), "fl_create_clock", 10630 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 10631 FL_Coord, STRING], 10632 """FL_OBJECT * fl_create_clock(int type, FL_Coord x, FL_Coord y, 10633 FL_Coord w, FL_Coord h, const char * s) 10634 """) 10635 check_admitted_listvalues(clocktype, CLOCKTYPE_list) 10636 iclocktype = convert_to_int(clocktype) 10637 ix = convert_to_FL_Coord(x) 10638 iy = convert_to_FL_Coord(y) 10639 iw = convert_to_FL_Coord(w) 10640 ih = convert_to_FL_Coord(h) 10641 slabel = convert_to_string(label) 10642 keep_elem_refs(clocktype, x, y, w, h, label, iclocktype, ix, iy, 10643 iw, ih, slabel) 10644 retval = _fl_create_clock(iclocktype, ix, iy, iw, ih, slabel) 10645 return retval
10646 10647
10648 -def fl_add_clock(clocktype, x, y, w, h, label):
10649 """ 10650 fl_add_clock(clocktype, x, y, w, h, label) -> pObject 10651 10652 Adds a clock object. 10653 10654 @param clocktype : type of clock object to be added 10655 @param x : horizontal position of clock (upper-left corner) 10656 @param x : vertical position of clock (upper-left corner) 10657 @param w : width of clock in pixels 10658 @param h : height of clock in pixels 10659 @param label : text label of clock 10660 """ 10661 10662 _fl_add_clock = cfuncproto( 10663 load_so_libforms(), "fl_add_clock", 10664 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 10665 FL_Coord, STRING], 10666 """FL_OBJECT * fl_add_clock(int type, FL_Coord x, FL_Coord y, 10667 FL_Coord w, FL_Coord h, const char * s) 10668 """) 10669 check_admitted_listvalues(clocktype, CLOCKTYPE_list) 10670 iclocktype = convert_to_int(clocktype) 10671 ix = convert_to_FL_Coord(x) 10672 iy = convert_to_FL_Coord(y) 10673 iw = convert_to_FL_Coord(w) 10674 ih = convert_to_FL_Coord(h) 10675 slabel = convert_to_string(label) 10676 keep_elem_refs(clocktype, x, y, w, h, label, iclocktype, ix, iy, 10677 iw, ih, slabel) 10678 retval = _fl_add_clock(iclocktype, ix, iy, iw, ih, slabel) 10679 return retval
10680 10681 10682 #def fl_get_clock(pObject, hr, mn, sec) *API change*
10683 -def fl_get_clock(pObject):
10684 """ fl_get_clock(pObject) -> hr, mn, sec 10685 10686 Returns time values from a clock object. 10687 10688 @param pObject : pointer to clock object 10689 """ 10690 10691 _fl_get_clock = cfuncproto( 10692 load_so_libforms(), "fl_get_clock", 10693 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 10694 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)], 10695 """void fl_get_clock(FL_OBJECT * ob, int * h, int * m, int * s) 10696 """) 10697 hr, phr = make_int_and_pointer() 10698 mn, pmn = make_int_and_pointer() 10699 sec, psec = make_int_and_pointer() 10700 keep_elem_refs(pObject, hr, mn, sec, phr, pmn, psec) 10701 _fl_get_clock(pObject, phr, pmn, psec) 10702 return hr, mn, sec
10703 10704
10705 -def fl_set_clock_adjustment(pObject, offset):
10706 """ fl_set_clock_adjustment(pObject, offset) -> num. 10707 """ 10708 10709 _fl_set_clock_adjustment = cfuncproto( 10710 load_so_libforms(), "fl_set_clock_adjustment", 10711 cty.c_long, [cty.POINTER(FL_OBJECT), cty.c_long], 10712 """long int fl_set_clock_adjustment(FL_OBJECT * ob, 10713 long int offset) 10714 """) 10715 loffset = convert_to_long(offset) 10716 keep_elem_refs(pObject, offset, loffset) 10717 retval = _fl_set_clock_adjustment(pObject, loffset) 10718 return retval
10719 10720
10721 -def fl_set_clock_ampm(pObject, y):
10722 """ fl_set_clock_ampm(pObject, y) 10723 """ 10724 10725 _fl_set_clock_ampm = cfuncproto( 10726 load_so_libforms(), "fl_set_clock_ampm", 10727 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10728 """void fl_set_clock_ampm(FL_OBJECT * ob, int y) 10729 """) 10730 iy = convert_to_int(y) 10731 keep_elem_refs(pObject, y, iy) 10732 _fl_set_clock_ampm(pObject, iy)
10733 10734 10735 10736 ###################### 10737 # forms.h (counter.h) 10738 ###################### 10739 10740 # Routines 10741
10742 -def fl_create_counter(countertype, x, y, w, h, label):
10743 """ 10744 fl_create_counter(countertype, x, y, w, h, label) -> pObject 10745 10746 Creates a counter object. 10747 10748 @param countertype : type of counter object to be created 10749 @param x : horizontal position of counter (upper-left corner) 10750 @param x : vertical position of counter (upper-left corner) 10751 @param w : width of counter in pixels 10752 @param h : height of counter in pixels 10753 @param label : text label of counter 10754 """ 10755 10756 _fl_create_counter = cfuncproto( 10757 load_so_libforms(), "fl_create_counter", 10758 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 10759 FL_Coord, STRING], 10760 """FL_OBJECT * fl_create_counter(int type, FL_Coord x, FL_Coord y, 10761 FL_Coord w, FL_Coord h, const char * label) 10762 """) 10763 check_admitted_listvalues(countertype, COUNTERTYPE_list) 10764 icountertype = convert_to_int(countertype) 10765 ix = convert_to_FL_Coord(x) 10766 iy = convert_to_FL_Coord(y) 10767 iw = convert_to_FL_Coord(w) 10768 ih = convert_to_FL_Coord(h) 10769 slabel = convert_to_string(label) 10770 keep_elem_refs(countertype, x, y, w, h, label, icountertype, ix, iy, 10771 iw, ih, slabel) 10772 retval = _fl_create_counter(icountertype, ix, iy, iw, ih, slabel) 10773 return retval
10774 10775
10776 -def fl_add_counter(countertype, x, y, w, h, label):
10777 """ 10778 fl_add_counter(countertype, x, y, w, h, label) -> pObject 10779 10780 Adds a counter object. 10781 10782 @param countertype : type of counter object to be added 10783 @param x : horizontal position of counter (upper-left corner) 10784 @param x : vertical position of counter (upper-left corner) 10785 @param w : width of counter in pixels 10786 @param h : height of counter in pixels 10787 @param label : text label of counter 10788 """ 10789 10790 _fl_add_counter = cfuncproto( 10791 load_so_libforms(), "fl_add_counter", 10792 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 10793 FL_Coord, STRING], 10794 """FL_OBJECT * fl_add_counter(int type, FL_Coord x, FL_Coord y, 10795 FL_Coord w, FL_Coord h, const char * label) 10796 """) 10797 check_admitted_listvalues(countertype, COUNTERTYPE_list) 10798 icountertype = convert_to_int(countertype) 10799 ix = convert_to_FL_Coord(x) 10800 iy = convert_to_FL_Coord(y) 10801 iw = convert_to_FL_Coord(w) 10802 ih = convert_to_FL_Coord(h) 10803 slabel = convert_to_string(label) 10804 keep_elem_refs(countertype, x, y, w, h, label, icountertype, ix, iy, 10805 iw, ih, slabel) 10806 retval = _fl_add_counter(icountertype, ix, iy, iw, ih, slabel) 10807 return retval
10808 10809
10810 -def fl_set_counter_value(pObject, val):
10811 """ fl_set_counter_value(pObject, val) 10812 """ 10813 10814 _fl_set_counter_value = cfuncproto( 10815 load_so_libforms(), "fl_set_counter_value", 10816 None, [cty.POINTER(FL_OBJECT), cty.c_double], 10817 """void fl_set_counter_value(FL_OBJECT * ob, double val) 10818 """) 10819 fval = convert_to_double(val) 10820 keep_elem_refs(pObject, val, fval) 10821 _fl_set_counter_value(pObject, fval)
10822 10823
10824 -def fl_set_counter_bounds(pObject, minbound, maxbound):
10825 """ fl_set_counter_bounds(pObject, minbound, maxbound) 10826 """ 10827 10828 _fl_set_counter_bounds = cfuncproto( 10829 load_so_libforms(), "fl_set_counter_bounds", 10830 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 10831 """void fl_set_counter_bounds(FL_OBJECT * ob, double min, 10832 double max) 10833 """) 10834 fminbound = convert_to_double(minbound) 10835 fmaxbound = convert_to_double(maxbound) 10836 keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 10837 _fl_set_counter_bounds(pObject, fminbound, fmaxbound)
10838 10839
10840 -def fl_set_counter_step(pObject, s, l):
10841 """ fl_set_counter_step(pObject, s, l) 10842 """ 10843 10844 _fl_set_counter_step = cfuncproto( 10845 load_so_libforms(), "fl_set_counter_step", 10846 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 10847 """void fl_set_counter_step(FL_OBJECT * ob, double s, double l) 10848 """) 10849 fs = convert_to_double(s) 10850 fl = convert_to_double(l) 10851 keep_elem_refs(pObject, s, l, fs, fl) 10852 _fl_set_counter_step(pObject, fs, fl)
10853 10854
10855 -def fl_set_counter_precision(pObject, prec):
10856 """ fl_set_counter_precision(pObject, prec) 10857 """ 10858 10859 _fl_set_counter_precision = cfuncproto( 10860 load_so_libforms(), "fl_set_counter_precision", 10861 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10862 """void fl_set_counter_precision(FL_OBJECT * ob, int prec) 10863 """) 10864 iprec = convert_to_int(prec) 10865 keep_elem_refs(pObject, prec, iprec) 10866 _fl_set_counter_precision(pObject, iprec)
10867 10868
10869 -def fl_get_counter_precision(pObject):
10870 """ fl_get_counter_precision(pObject) -> num. 10871 """ 10872 10873 _fl_get_counter_precision = cfuncproto( 10874 load_so_libforms(), "fl_get_counter_precision", 10875 cty.c_int, [cty.POINTER(FL_OBJECT)], 10876 """int fl_get_counter_precision(FL_OBJECT * ob) 10877 """) 10878 keep_elem_refs(pObject) 10879 retval = _fl_get_counter_precision(pObject) 10880 return retval
10881 10882
10883 -def fl_set_counter_return(pObject, how):
10884 """ fl_set_counter_return(pObject, how) 10885 """ 10886 10887 _fl_set_counter_return = cfuncproto( 10888 load_so_libforms(), "fl_set_counter_return", 10889 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10890 """void fl_set_counter_return(FL_OBJECT * ob, int how) 10891 """) 10892 ihow = convert_to_int(how) 10893 keep_elem_refs(pObject, how, ihow) 10894 _fl_set_counter_return(pObject, ihow)
10895 10896
10897 -def fl_get_counter_value(pObject):
10898 """ fl_get_counter_value(pObject) -> num. 10899 """ 10900 10901 _fl_get_counter_value = cfuncproto( 10902 load_so_libforms(), "fl_get_counter_value", 10903 cty.c_double, [cty.POINTER(FL_OBJECT)], 10904 """double fl_get_counter_value(FL_OBJECT * ob) 10905 """) 10906 keep_elem_refs(pObject) 10907 retval = _fl_get_counter_value(pObject) 10908 return retval
10909 10910 10911 #def fl_get_counter_bounds(pObject, minbound, maxbound) *API change*
10912 -def fl_get_counter_bounds(pObject):
10913 """ fl_get_counter_bounds(pObject) -> minbound, maxbound 10914 """ 10915 10916 _fl_get_counter_bounds = cfuncproto( 10917 load_so_libforms(), "fl_get_counter_bounds", 10918 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 10919 cty.POINTER(cty.c_double)], 10920 """void fl_get_counter_bounds(FL_OBJECT * ob, double * min, 10921 double * max) 10922 """) 10923 minbound, pminbound = make_double_and_pointer() 10924 maxbound, pmaxbound = make_double_and_pointer() 10925 keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 10926 _fl_get_counter_bounds(pObject, pminbound, pmaxbound) 10927 return minbound, maxbound
10928 10929 10930 #def fl_get_counter_step(pObject, s, l) *API change*
10931 -def fl_get_counter_step(pObject):
10932 """ fl_get_counter_step(pObject) -> s, l 10933 """ 10934 10935 _fl_get_counter_step = cfuncproto( 10936 load_so_libforms(), "fl_get_counter_step", 10937 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 10938 cty.POINTER(cty.c_double)], 10939 """void fl_get_counter_step(FL_OBJECT * ob, double * s, 10940 double * l) 10941 """) 10942 s, ps = make_double_and_pointer() 10943 l, pl = make_double_and_pointer() 10944 keep_elem_refs(pObject, s, l, ps, pl) 10945 _fl_get_counter_step(pObject, ps, pl) 10946 return s, l
10947 10948 10949 FL_VAL_FILTER = cty.CFUNCTYPE(STRING, cty.POINTER(FL_OBJECT), cty.c_double, \ 10950 cty.c_int) 10951
10952 -def fl_set_counter_filter(pObject, py_ValFilter):
10953 """ fl_set_counter_filter(pObject, ValFilter) 10954 """ 10955 10956 _fl_set_counter_filter = cfuncproto( 10957 load_so_libforms(), "fl_set_counter_filter", 10958 None, [cty.POINTER(FL_OBJECT), FL_VAL_FILTER], 10959 """void fl_set_counter_filter(FL_OBJECT * ob, 10960 FL_VAL_FILTER filter) 10961 """) 10962 c_ValFilter = FL_VAL_FILTER(py_ValFilter) 10963 keep_cfunc_refs(c_ValFilter, py_ValFilter) 10964 keep_elem_refs(pObject) 10965 _fl_set_counter_filter(pObject, c_ValFilter)
10966 10967 10968 # Functions to set and get the timeout value used by the 10969 # counter code to control modification of the counter value. 10970
10971 -def fl_get_counter_repeat(pObject):
10972 """ fl_get_counter_repeat(pObject) -> num. 10973 """ 10974 10975 _fl_get_counter_repeat = cfuncproto( 10976 load_so_libforms(), "fl_get_counter_repeat", 10977 cty.c_int, [cty.POINTER(FL_OBJECT)], 10978 """int fl_get_counter_repeat(FL_OBJECT * ob) 10979 """) 10980 keep_elem_refs(pObject) 10981 retval = _fl_get_counter_repeat(pObject) 10982 return retval
10983 10984
10985 -def fl_set_counter_repeat(pObject, msec):
10986 """ fl_set_counter_repeat(pObject, msec) 10987 """ 10988 10989 _fl_set_counter_repeat = cfuncproto( 10990 load_so_libforms(), "fl_set_counter_repeat", 10991 None, [cty.POINTER(FL_OBJECT), cty.c_int], 10992 """void fl_set_counter_repeat(FL_OBJECT * ob, int millisec) 10993 """) 10994 imsec = convert_to_int(msec) 10995 keep_elem_refs(pObject, msec, imsec) 10996 _fl_set_counter_repeat(pObject, imsec)
10997 10998
10999 -def fl_get_counter_min_repeat(pObject):
11000 """ fl_get_counter_min_repeat(pObject) -> num. 11001 """ 11002 11003 _fl_get_counter_min_repeat = cfuncproto( 11004 load_so_libforms(), "fl_get_counter_min_repeat", 11005 cty.c_int, [cty.POINTER(FL_OBJECT)], 11006 """int fl_get_counter_min_repeat(FL_OBJECT * ob) 11007 """) 11008 keep_elem_refs(pObject) 11009 retval = _fl_get_counter_min_repeat(pObject) 11010 return retval
11011 11012
11013 -def fl_set_counter_min_repeat(pObject, msec):
11014 """ fl_set_counter_min_repeat(pObject, msec) 11015 """ 11016 11017 _fl_set_counter_min_repeat = cfuncproto( 11018 load_so_libforms(), "fl_set_counter_min_repeat", 11019 None, [cty.POINTER(FL_OBJECT), cty.c_int], 11020 """void fl_set_counter_min_repeat(FL_OBJECT * ob, int millisec) 11021 """) 11022 imsec = convert_to_int(msec) 11023 keep_elem_refs(pObject, msec, imsec) 11024 _fl_set_counter_min_repeat(pObject, imsec)
11025 11026
11027 -def fl_get_counter_speedjump(pObject):
11028 """ fl_get_counter_speedjump(pObject) -> num. 11029 """ 11030 11031 _fl_get_counter_speedjump = cfuncproto( 11032 load_so_libforms(), "fl_get_counter_speedjump", 11033 cty.c_int, [cty.POINTER(FL_OBJECT)], 11034 """int fl_get_counter_speedjump(FL_OBJECT * ob) 11035 """) 11036 keep_elem_refs(pObject) 11037 retval = _fl_get_counter_speedjump(pObject) 11038 return retval
11039 11040
11041 -def fl_set_counter_speedjump(pObject, yesno):
11042 """ fl_set_counter_speedjump(pObject, yesno) 11043 """ 11044 11045 _fl_set_counter_speedjump = cfuncproto( 11046 load_so_libforms(), "fl_set_counter_speedjump", 11047 None, [cty.POINTER(FL_OBJECT), cty.c_int], 11048 """void fl_set_counter_speedjump(FL_OBJECT * ob, int yes_no) 11049 """) 11050 iyesno = convert_to_int(yesno) 11051 keep_elem_refs(pObject, yesno, iyesno) 11052 _fl_set_counter_speedjump(pObject, iyesno)
11053 11054 11055 11056 ############################# 11057 # forms.h (cursor.h) 11058 # Cursor defs and prototypes 11059 ############################# 11060
11061 -def fl_set_cursor(win, cursnum):
11062 """ 11063 fl_set_cursor(win, cursnum) 11064 11065 Set cursor for window to provided cursor number name. Name 11066 is either the standard XC_ or Form defined 11067 11068 @param win : window 11069 @param cursnum : cursor number 11070 """ 11071 11072 _fl_set_cursor = cfuncproto( 11073 load_so_libforms(), "fl_set_cursor", 11074 None, [Window, cty.c_int], 11075 """void fl_set_cursor(Window win, int name) 11076 """) 11077 ulwin = convert_to_Window(win) 11078 icursnum = convert_to_int(cursnum) 11079 keep_elem_refs(win, cursnum, ulwin, icursnum) 11080 _fl_set_cursor(ulwin, icursnum)
11081 11082
11083 -def fl_set_cursor_color(cursnum, fgcolr, bgcolr):
11084 """ 11085 fl_set_cursor_color(cursnum, fgcolr, bgcolr) 11086 11087 Sets foreground and background colors for cursor. 11088 11089 @param cursnum : cursor number 11090 @param fgcolr : foreground color to be set 11091 @param bgcolr : background color to be set 11092 """ 11093 11094 _fl_set_cursor_color = cfuncproto( 11095 load_so_libforms(), "fl_set_cursor_color", 11096 None, [cty.c_int, FL_COLOR, FL_COLOR], 11097 """void fl_set_cursor_color(int name, FL_COLOR fg, FL_COLOR bg) 11098 """) 11099 icursnum = convert_to_int(cursnum) 11100 ulfgcolr = convert_to_FL_COLOR(fgcolr) 11101 ulbgcolr = convert_to_FL_COLOR(bgcolr) 11102 keep_elem_refs(cursnum, fgcolr, bgcolr, icursnum, ulfgcolr, ulbgcolr) 11103 _fl_set_cursor_color(icursnum, ulfgcolr, ulbgcolr)
11104 11105
11106 -def fl_create_bitmap_cursor(source, maskstr, w, h, hotx, hoty):
11107 """ fl_create_bitmap_cursor(source, maskstr, w, h, hotx, hoty) -> num. 11108 """ 11109 11110 _fl_create_bitmap_cursor = cfuncproto( 11111 load_so_libforms(), "fl_create_bitmap_cursor", 11112 cty.c_int, [STRING, STRING, cty.c_int, cty.c_int, cty.c_int, 11113 cty.c_int], 11114 """int fl_create_bitmap_cursor(const char * source, 11115 const char * mask, int w, int h, int hotx, int hoty) 11116 """) 11117 ssource = convert_to_string(source) 11118 smaskstr = convert_to_string(maskstr) 11119 iw = convert_to_int(w) 11120 ih = convert_to_FL_Coord(h) 11121 ihotx = convert_to_int(hotx) 11122 ihoty = convert_to_int(hoty) 11123 keep_elem_refs(source, maskstr, w, h, hotx, hoty, ssource, smaskstr, 11124 iw, ih, ihotx, ihoty) 11125 retval = _fl_create_bitmap_cursor(ssource, smaskstr, iw, ih, ihotx, ihoty) 11126 return retval
11127 11128
11129 -def fl_create_animated_cursor(curnums, timeout):
11130 """ fl_create_animated_cursor(curnums, timeout) -> num. 11131 """ 11132 11133 _fl_create_animated_cursor = cfuncproto( 11134 load_so_libforms(), "fl_create_animated_cursor", 11135 cty.c_int, [cty.POINTER(cty.c_int), cty.c_int], 11136 """int fl_create_animated_cursor(int * cur_names, int timeout) 11137 """) 11138 pcurnums = cty.cast(curnums, cty.POINTER(cty.c_int)) 11139 #print "pcurnums", pcurnums 11140 itimeout = convert_to_int(timeout) 11141 keep_elem_refs(curnums, timeout, pcurnums, itimeout) 11142 retval = _fl_create_animated_cursor(pcurnums, itimeout) 11143 return retval
11144 11145
11146 -def fl_get_cursor_byname(cursnum):
11147 """ 11148 fl_get_cursor_byname(cursnum) -> cursor 11149 11150 Return cursor corresponding to number. 11151 11152 @param cursnum : cursor number 11153 """ 11154 11155 _fl_get_cursor_byname = cfuncproto( 11156 load_so_libforms(), "fl_get_cursor_byname", 11157 Cursor, [cty.c_int], 11158 """Cursor fl_get_cursor_byname(int name) 11159 """) 11160 icursnum = convert_to_int(cursnum) 11161 keep_elem_refs(cursnum, icursnum) 11162 retval = _fl_get_cursor_byname(icursnum) 11163 return retval
11164 11165
11166 -def fl_reset_cursor(win):
11167 """ 11168 Reset used cursor, reverting to default one. 11169 """ 11170 11171 fl_set_cursor(win, FL_DEFAULT_CURSOR)
11172 11173 11174 11175 ################### 11176 # forms.h (dial.h) 11177 ################### 11178 11179 # Routines 11180
11181 -def fl_create_dial(dialtype, x, y, w, h, label):
11182 """ fl_create_dial(dialtype, x, y, w, h, label) -> pObject 11183 """ 11184 11185 _fl_create_dial = cfuncproto( 11186 load_so_libforms(), "fl_create_dial", 11187 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 11188 FL_Coord, STRING], 11189 """FL_OBJECT * fl_create_dial(int type, FL_Coord x, FL_Coord y, 11190 FL_Coord w, FL_Coord h, const char * label) 11191 """) 11192 check_admitted_listvalues(dialtype, DIALTYPE_list) 11193 idialtype = convert_to_int(dialtype) 11194 ix = convert_to_FL_Coord(x) 11195 iy = convert_to_FL_Coord(y) 11196 iw = convert_to_FL_Coord(w) 11197 ih = convert_to_FL_Coord(h) 11198 slabel = convert_to_string(label) 11199 keep_elem_refs(dialtype, x, y, w, h, label, idialtype, ix, iy, 11200 iw, ih, slabel) 11201 retval = _fl_create_dial(idialtype, ix, iy, iw, ih, slabel) 11202 return retval
11203 11204
11205 -def fl_add_dial(dialtype, x, y, w, h, label):
11206 """ fl_add_dial(dialtype, x, y, w, h, label) -> pObject 11207 """ 11208 11209 _fl_add_dial = cfuncproto( 11210 load_so_libforms(), "fl_add_dial", 11211 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 11212 FL_Coord, STRING], 11213 """FL_OBJECT * fl_add_dial(int type, FL_Coord x, FL_Coord y, 11214 FL_Coord w, FL_Coord h, const char * label) 11215 """) 11216 check_admitted_listvalues(dialtype, DIALTYPE_list) 11217 idialtype = convert_to_int(dialtype) 11218 ix = convert_to_FL_Coord(x) 11219 iy = convert_to_FL_Coord(y) 11220 iw = convert_to_FL_Coord(w) 11221 ih = convert_to_FL_Coord(h) 11222 slabel = convert_to_string(label) 11223 keep_elem_refs(dialtype, x, y, w, h, label, idialtype, ix, iy, 11224 iw, ih, slabel) 11225 retval = _fl_add_dial(idialtype, ix, iy, iw, ih, slabel) 11226 return retval
11227 11228
11229 -def fl_set_dial_value(pObject, val):
11230 """ fl_set_dial_value(pObject, val) 11231 """ 11232 11233 _fl_set_dial_value = cfuncproto( 11234 load_so_libforms(), "fl_set_dial_value", 11235 None, [cty.POINTER(FL_OBJECT), cty.c_double], 11236 """void fl_set_dial_value(FL_OBJECT * ob, double val) 11237 """) 11238 fval = convert_to_double(val) 11239 keep_elem_refs(pObject, val, fval) 11240 _fl_set_dial_value(pObject, fval)
11241 11242
11243 -def fl_get_dial_value(pObject):
11244 """ fl_get_dial_value(pObject) -> num. 11245 """ 11246 11247 _fl_get_dial_value = cfuncproto( 11248 load_so_libforms(), "fl_get_dial_value", 11249 cty.c_double, [cty.POINTER(FL_OBJECT)], 11250 """double fl_get_dial_value(FL_OBJECT * ob) 11251 """) 11252 keep_elem_refs(pObject) 11253 retval = _fl_get_dial_value(pObject) 11254 return retval
11255 11256
11257 -def fl_set_dial_bounds(pObject, minbound, maxbound):
11258 """ fl_set_dial_bounds(pObject, minbound, maxbound) 11259 """ 11260 11261 _fl_set_dial_bounds = cfuncproto( 11262 load_so_libforms(), "fl_set_dial_bounds", 11263 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 11264 """void fl_set_dial_bounds(FL_OBJECT * ob, double min, 11265 double max) 11266 """) 11267 fminbound = convert_to_double(minbound) 11268 fmaxbound = convert_to_double(maxbound) 11269 keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 11270 _fl_set_dial_bounds(pObject, fminbound, fmaxbound)
11271 11272 11273 #def fl_get_dial_bounds(pObject, minbound, maxbound) *API change*
11274 -def fl_get_dial_bounds(pObject):
11275 """ fl_get_dial_bounds(pObject) -> minbound, maxbound 11276 """ 11277 11278 _fl_get_dial_bounds = cfuncproto( 11279 load_so_libforms(), "fl_get_dial_bounds", 11280 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 11281 cty.POINTER(cty.c_double)], 11282 """void fl_get_dial_bounds(FL_OBJECT * ob, double * min, 11283 double * max) 11284 """) 11285 minbound, pminbound = make_double_and_pointer() 11286 maxbound, pmaxbound = make_double_and_pointer() 11287 keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 11288 _fl_get_dial_bounds(pObject, pminbound, pmaxbound) 11289 return minbound, maxbound
11290 11291
11292 -def fl_set_dial_step(pObject, value):
11293 """ fl_set_dial_step(pObject, value) 11294 """ 11295 11296 _fl_set_dial_step = cfuncproto( 11297 load_so_libforms(), "fl_set_dial_step", 11298 None, [cty.POINTER(FL_OBJECT), cty.c_double], 11299 """void fl_set_dial_step(FL_OBJECT * ob, double value) 11300 """) 11301 fvalue = convert_to_double(value) 11302 keep_elem_refs(pObject, value, fvalue) 11303 _fl_set_dial_step(pObject, fvalue)
11304 11305
11306 -def fl_set_dial_return(pObject, value):
11307 """ fl_set_dial_return(pObject, value) 11308 """ 11309 11310 _fl_set_dial_return = cfuncproto( 11311 load_so_libforms(), "fl_set_dial_return", 11312 None, [cty.POINTER(FL_OBJECT), cty.c_int], 11313 """void fl_set_dial_return(FL_OBJECT * ob, int value) 11314 """) 11315 ivalue = convert_to_int(value) 11316 keep_elem_refs(pObject, value, ivalue) 11317 _fl_set_dial_return(pObject, ivalue)
11318 11319
11320 -def fl_set_dial_angles(pObject, angmin, angmax):
11321 """ fl_set_dial_angles(pObject, angmin, angmax) 11322 """ 11323 11324 _fl_set_dial_angles = cfuncproto( 11325 load_so_libforms(), "fl_set_dial_angles", 11326 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 11327 """void fl_set_dial_angles(FL_OBJECT * ob, double amin, 11328 double amax) 11329 """) 11330 fangmin = convert_to_double(angmin) 11331 fangmax = convert_to_double(angmax) 11332 keep_elem_refs(pObject, angmin, angmax, fangmin, fangmax) 11333 _fl_set_dial_angles(pObject, fangmin, fangmax)
11334 11335
11336 -def fl_set_dial_cross(pObject, flag):
11337 """ fl_set_dial_cross(pObject, flag) 11338 """ 11339 11340 _fl_set_dial_cross = cfuncproto( 11341 load_so_libforms(), "fl_set_dial_cross", 11342 None, [cty.POINTER(FL_OBJECT), cty.c_int], 11343 """void fl_set_dial_cross(FL_OBJECT * ob, int flag) 11344 """) 11345 iflag = convert_to_int(flag) 11346 keep_elem_refs(pObject, flag, iflag) 11347 _fl_set_dial_cross(pObject, iflag)
11348 11349 11350 fl_set_dial_crossover = fl_set_dial_cross 11351 11352
11353 -def fl_set_dial_direction(pObject, directn):
11354 """ fl_set_dial_direction(pObject, directn) 11355 """ 11356 11357 _fl_set_dial_direction = cfuncproto( 11358 load_so_libforms(), "fl_set_dial_direction", 11359 None, [cty.POINTER(FL_OBJECT), cty.c_int], 11360 """void fl_set_dial_direction(FL_OBJECT * ob, int dir) 11361 """) 11362 idirectn = convert_to_int(directn) 11363 keep_elem_refs(pObject, directn, idirectn) 11364 _fl_set_dial_direction(pObject, idirectn)
11365 11366 11367 11368 ############################################ 11369 # forms.h (filesys.h) 11370 # Convenience functions to read a directory 11371 ############################################ 11372 11373 # read dir with pattern filtering. All dirs read might be cached. 11374 # must not change dirlist in anyway. 11375 11376 #def fl_get_dirlist(directory, pattern, n, rescan) *API change*
11377 -def fl_get_dirlist(directory, pattern, rescan):
11378 """ fl_get_dirlist(directory, pattern, rescan) -> pDirList, n 11379 """ 11380 11381 _fl_get_dirlist = cfuncproto( 11382 load_so_libforms(), "fl_get_dirlist", 11383 cty.POINTER(FL_Dirlist), [STRING, STRING, cty.POINTER(cty.c_int), 11384 cty.c_int], 11385 """const char * fl_get_dirlist(const char * dir, 11386 const char * pattern, int * n, int rescan) 11387 """) 11388 sdirectory = convert_to_string(directory) 11389 spattern = convert_to_string(pattern) 11390 n, pn = make_int_and_pointer() 11391 irescan = convert_to_int(rescan) 11392 keep_elem_refs(directory, pattern, n, rescan, sdirectory, spattern, 11393 pn, irescan) 11394 retval = _fl_get_dirlist(sdirectory, spattern, pn, irescan) 11395 return retval, n
11396 11397 11398 FL_DIRLIST_FILTER = cty.CFUNCTYPE(cty.c_int, STRING, cty.c_int) 11399
11400 -def fl_set_dirlist_filter(py_DirFilter):
11401 """ fl_set_dirlist_filter(py_DirFilter) -> dirlist_filter func. 11402 """ 11403 11404 _fl_set_dirlist_filter = cfuncproto( 11405 load_so_libforms(), "fl_set_dirlist_filter", 11406 FL_DIRLIST_FILTER, [FL_DIRLIST_FILTER], 11407 """FL_DIRLIST_FILTER fl_set_dirlist_filter( \ 11408 FL_DIRLIST_FILTER filter) 11409 """) 11410 c_DirFilter = FL_DIRLIST_FILTER(py_DirFilter) 11411 keep_cfunc_refs(c_DirFilter, py_DirFilter) 11412 retval = _fl_set_dirlist_filter(c_DirFilter) 11413 return retval
11414 11415
11416 -def fl_set_dirlist_sort(method):
11417 """ fl_set_dirlist_sort(method) -> num. 11418 """ 11419 11420 _fl_set_dirlist_sort = cfuncproto( 11421 load_so_libforms(), "fl_set_dirlist_sort", 11422 cty.c_int, [cty.c_int], 11423 """int fl_set_dirlist_sort(int method) 11424 """) 11425 imethod = convert_to_int(method) 11426 keep_elem_refs(method, imethod) 11427 retval = _fl_set_dirlist_sort(imethod) 11428 return retval
11429 11430
11431 -def fl_set_dirlist_filterdir(yes):
11432 """ fl_set_dirlist_filterdir(yes) -> num. 11433 """ 11434 11435 _fl_set_dirlist_filterdir = cfuncproto( 11436 load_so_libforms(), "fl_set_dirlist_filterdir", 11437 cty.c_int, [cty.c_int], 11438 """int fl_set_dirlist_filterdir(int yes) 11439 """) 11440 iyes = convert_to_int(yes) 11441 keep_elem_refs(yes, iyes) 11442 retval = _fl_set_dirlist_filterdir(iyes) 11443 return retval
11444 11445
11446 -def fl_free_dirlist(pDirList):
11447 """ fl_free_dirlist(pDirList) 11448 """ 11449 11450 _fl_free_dirlist = cfuncproto( 11451 load_so_libforms(), "fl_free_dirlist", 11452 None, [cty.POINTER(FL_Dirlist)], 11453 """void fl_free_dirlist(FL_Dirlist * dl) 11454 """) 11455 keep_elem_refs(pDirList) 11456 _fl_free_dirlist(pDirList)
11457 11458 11459 # Free all directory caches 11460
11461 -def fl_free_all_dirlist():
11462 """ fl_free_all_dirlist() 11463 """ 11464 11465 _fl_free_all_dirlist = cfuncproto( 11466 load_so_libforms(), "fl_free_all_dirlist", 11467 None, [], 11468 """void fl_free_all_dirlist() 11469 """) 11470 _fl_free_all_dirlist()
11471 11472
11473 -def fl_is_valid_dir(name):
11474 """ fl_is_valid_dir(name) -> num. 11475 """ 11476 11477 _fl_is_valid_dir = cfuncproto( 11478 load_so_libforms(), "fl_is_valid_dir", 11479 cty.c_int, [STRING], 11480 """int fl_is_valid_dir(const char * name) 11481 """) 11482 sname = convert_to_string(name) 11483 keep_elem_refs(name, sname) 11484 retval = _fl_is_valid_dir(sname) 11485 return retval
11486 11487
11488 -def fl_fmtime(timestr):
11489 """ fl_fmtime(timestr) -> num. 11490 """ 11491 11492 _fl_fmtime = cfuncproto( 11493 load_so_libforms(), "fl_fmtime", 11494 cty.c_ulong, [STRING], 11495 """long unsigned int fl_fmtime(const char * s) 11496 """) 11497 stimestr = convert_to_string(timestr) 11498 keep_elem_refs(timestr, stimestr) 11499 retval = _fl_fmtime(stimestr) 11500 return retval
11501 11502
11503 -def fl_fix_dirname(directory):
11504 """ fl_fix_dirname(directory) -> dirname string 11505 """ 11506 11507 _fl_fix_dirname = cfuncproto( 11508 load_so_libforms(), "fl_fix_dirname", 11509 STRING, [STRING], 11510 """char * fl_fix_dirname(char * dir) 11511 """) 11512 sdirectory = convert_to_string(directory) 11513 keep_elem_refs(directory, sdirectory) 11514 retval = _fl_fix_dirname(sdirectory) 11515 return retval
11516 11517 11518 11519 ################### 11520 # forms.h (flps.h) 11521 ################### 11522 11523 # postscript stuff 11524
11525 -def flps_init():
11526 """ flps_init() -> flps_control class 11527 """ 11528 11529 _flps_init = cfuncproto( 11530 load_so_libflimage(), "flps_init", 11531 cty.POINTER(FLPS_CONTROL), [], 11532 """)FLPS_CONTROL * flps_init() 11533 """) 11534 retval = _flps_init() 11535 return retval
11536 11537
11538 -def fl_object_ps_dump(pObject, fname):
11539 """ fl_object_ps_dump(pObject, fname) -> num. 11540 """ 11541 11542 _fl_object_ps_dump = cfuncproto( 11543 load_so_libflimage(), "fl_object_ps_dump", 11544 cty.c_int, [cty.POINTER(FL_OBJECT), STRING], 11545 """int fl_object_ps_dump(FL_OBJECT * ob, const char * fname) 11546 """) 11547 sfname = convert_to_string(fname) 11548 keep_elem_refs(pObject, fname, sfname) 11549 retval = _fl_object_ps_dump(pObject, sfname) 11550 return retval
11551 11552 11553 11554 ########################## 11555 # forms.h (formbrowser.h) 11556 ########################## 11557
11558 -def fl_addto_formbrowser(pObject, pForm):
11559 """ fl_addto_formbrowser(pObject, pForm) -> num. 11560 """ 11561 11562 _fl_addto_formbrowser = cfuncproto( 11563 load_so_libforms(), "fl_addto_formbrowser", 11564 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_FORM)], 11565 """int fl_addto_formbrowser(FL_OBJECT * ob, FL_FORM * form) 11566 """) 11567 keep_elem_refs(pObject, pForm) 11568 retval = _fl_addto_formbrowser(pObject, pForm) 11569 return retval
11570 11571
11572 -def fl_delete_formbrowser_bynumber(pObject, num):
11573 """ fl_delete_formbrowser_bynumber(pObject, num) -> pForm 11574 """ 11575 11576 _fl_delete_formbrowser_bynumber = cfuncproto( 11577 load_so_libforms(), "fl_delete_formbrowser_bynumber", 11578 cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT), cty.c_int], 11579 """FL_FORM * fl_delete_formbrowser_bynumber(FL_OBJECT * ob, 11580 int num) 11581 """) 11582 inum = convert_to_int(num) 11583 keep_elem_refs(pObject, num, inum) 11584 retval = _fl_delete_formbrowser_bynumber(pObject, inum) 11585 return retval
11586 11587
11588 -def fl_delete_formbrowser(pObject, pFormCandidate):
11589 """ fl_delete_formbrowser(pObject, pFormCandidate) -> num. 11590 """ 11591 11592 _fl_delete_formbrowser = cfuncproto( 11593 load_so_libforms(), "fl_delete_formbrowser", 11594 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_FORM)], 11595 """int fl_delete_formbrowser(FL_OBJECT * ob, 11596 FL_FORM * candidate_form) 11597 """) 11598 keep_elem_refs(pObject, pFormCandidate) 11599 retval = _fl_delete_formbrowser(pObject, pFormCandidate) 11600 return retval
11601 11602
11603 -def fl_replace_formbrowser(pObject, num, pForm):
11604 """ fl_replace_formbrowser(pObject, num, pForm) 11605 """ 11606 11607 _fl_replace_formbrowser = cfuncproto( 11608 load_so_libforms(), "fl_replace_formbrowser", 11609 cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT), cty.c_int, 11610 cty.POINTER(FL_FORM)], 11611 """FL_FORM * fl_replace_formbrowser(FL_OBJECT * ob, int num, 11612 FL_FORM * form) 11613 """) 11614 inum = convert_to_int(num) 11615 keep_elem_refs(pObject, num, pForm, inum) 11616 retval = _fl_replace_formbrowser(pObject, inum, pForm) 11617 return retval
11618 11619
11620 -def fl_insert_formbrowser(pObject, line, pFormNew):
11621 """ fl_insert_formbrowser(pObject, line, pFormNew) -> num. 11622 """ 11623 11624 _fl_insert_formbrowser = cfuncproto( 11625 load_so_libforms(), "fl_insert_formbrowser", 11626 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int, \ 11627 cty.POINTER(FL_FORM)], 11628 """int fl_insert_formbrowser(FL_OBJECT * ob, int line, 11629 FL_FORM * new_form) 11630 """) 11631 iline = convert_to_int(line) 11632 keep_elem_refs(pObject, line, iline, pFormNew) 11633 retval = _fl_insert_formbrowser(pObject, iline, pFormNew) 11634 return retval
11635 11636 11637 #def fl_get_formbrowser_area(pObject, x, y, w, h) *API change*
11638 -def fl_get_formbrowser_area(pObject):
11639 """ fl_get_formbrowser_area(pObject) -> num., x, y, w, h 11640 """ 11641 11642 _fl_get_formbrowser_area = cfuncproto( 11643 load_so_libforms(), "fl_get_formbrowser_area", 11644 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 11645 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), \ 11646 cty.POINTER(cty.c_int)], 11647 """int fl_get_formbrowser_area(FL_OBJECT * ob, int * x, int * y, 11648 int * w, int * h) 11649 """) 11650 x, px = make_int_and_pointer() 11651 y, py = make_int_and_pointer() 11652 w, pw = make_int_and_pointer() 11653 h, ph = make_int_and_pointer() 11654 keep_elem_refs(pObject, x, y, w, h, px, py, pw, ph) 11655 retval = _fl_get_formbrowser_area(pObject, px, py, pw, ph) 11656 return retval, x, y, w, h
11657 11658
11659 -def fl_set_formbrowser_scroll(pObject, how):
11660 """ fl_set_formbrowser_scroll(pObject, how) 11661 """ 11662 11663 _fl_set_formbrowser_scroll = cfuncproto( 11664 load_so_libforms(), "fl_set_formbrowser_scroll", 11665 None, [cty.POINTER(FL_OBJECT), cty.c_int], 11666 """void fl_set_formbrowser_scroll(FL_OBJECT * ob, int how) 11667 """) 11668 ihow = convert_to_int(how) 11669 keep_elem_refs(pObject, how, ihow) 11670 _fl_set_formbrowser_scroll(pObject, ihow)
11671 11672
11673 -def fl_set_formbrowser_hscrollbar(pObject, how):
11674 """ fl_set_formbrowser_hscrollbar(pObject, how) 11675 """ 11676 11677 _fl_set_formbrowser_hscrollbar = cfuncproto( 11678 load_so_libforms(), "fl_set_formbrowser_hscrollbar", 11679 None, [cty.POINTER(FL_OBJECT), cty.c_int], 11680 """void fl_set_formbrowser_hscrollbar(FL_OBJECT * ob, int how) 11681 """) 11682 ihow = convert_to_int(how) 11683 keep_elem_refs(pObject, how, ihow) 11684 _fl_set_formbrowser_hscrollbar(pObject, ihow)
11685 11686
11687 -def fl_set_formbrowser_vscrollbar(pObject, how):
11688 """ fl_set_formbrowser_vscrollbar(pObject, how) 11689 """ 11690 11691 _fl_set_formbrowser_vscrollbar = cfuncproto( 11692 load_so_libforms(), "fl_set_formbrowser_vscrollbar", 11693 None, [cty.POINTER(FL_OBJECT), cty.c_int], 11694 """void fl_set_formbrowser_vscrollbar(FL_OBJECT * ob, int how) 11695 """) 11696 ihow = convert_to_int(how) 11697 keep_elem_refs(pObject, how, ihow) 11698 _fl_set_formbrowser_vscrollbar(pObject, ihow)
11699 11700
11701 -def fl_get_formbrowser_topform(pObject):
11702 """ fl_get_formbrowser_topform(pObject) -> pForm 11703 """ 11704 11705 _fl_get_formbrowser_topform = cfuncproto( 11706 load_so_libforms(), "fl_get_formbrowser_topform", 11707 cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT)], 11708 """FL_FORM * fl_get_formbrowser_topform(FL_OBJECT * ob) 11709 """) 11710 keep_elem_refs(pObject) 11711 retval = _fl_get_formbrowser_topform(pObject) 11712 return retval
11713 11714
11715 -def fl_set_formbrowser_topform(pObject, pForm):
11716 """ fl_set_formbrowser_topform(pObject, pForm) -> num. 11717 """ 11718 11719 _fl_set_formbrowser_topform = cfuncproto( 11720 load_so_libforms(), "fl_set_formbrowser_topform", 11721 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_FORM)], 11722 """int fl_set_formbrowser_topform(FL_OBJECT * ob, FL_FORM * form) 11723 """) 11724 keep_elem_refs(pObject, pForm) 11725 retval = _fl_set_formbrowser_topform(pObject, pForm) 11726 return retval
11727 11728
11729 -def fl_set_formbrowser_topform_bynumber(pObject, n):
11730 """ fl_set_formbrowser_topform_bynumber(pObject, n) -> pForm 11731 """ 11732 11733 _fl_set_formbrowser_topform_bynumber = cfuncproto( 11734 load_so_libforms(), "fl_set_formbrowser_topform_bynumber", 11735 cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT), cty.c_int], 11736 """FL_FORM * fl_set_formbrowser_topform_bynumber( \ 11737 FL_OBJECT * ob, int n) 11738 """) 11739 inum = convert_to_int(n) 11740 keep_elem_refs(pObject, n, inum) 11741 retval = _fl_set_formbrowser_topform_bynumber(pObject, inum) 11742 return retval
11743 11744
11745 -def fl_set_formbrowser_xoffset(pObject, offset):
11746 """ 11747 fl_set_formbrowser_xoffset(pObject, offset) -> num. 11748 11749 Scrolls within a formbrowser in horizontal direction. 11750 11751 @param pObject : pointer to formbrowser object 11752 @param offset : positive number, measuring in pixels the offset 11753 from the the natural position from the left 11754 """ 11755 11756 _fl_set_formbrowser_xoffset = cfuncproto( 11757 load_so_libforms(), "fl_set_formbrowser_xoffset", 11758 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 11759 """int fl_set_formbrowser_xoffset(FL_OBJECT * ob, int offset) 11760 """) 11761 ioffset = convert_to_int(offset) 11762 keep_elem_refs(pObject, offset, ioffset) 11763 retval = _fl_set_formbrowser_xoffset(pObject, ioffset) 11764 return retval
11765 11766
11767 -def fl_set_formbrowser_yoffset(pObject, offset):
11768 """ 11769 fl_set_formbrowser_yoffset(pObject, offset) -> num. 11770 11771 Scrolls within a formbrowser in vertical direction. 11772 11773 @param pObject : pointer to formbrowser object 11774 @param offset : positive number, measuring in pixels the offset 11775 from the the natural position from the top 11776 """ 11777 11778 _fl_set_formbrowser_yoffset = cfuncproto( 11779 load_so_libforms(), "fl_set_formbrowser_yoffset", 11780 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 11781 """int fl_set_formbrowser_yoffset(FL_OBJECT * ob, int offset) 11782 """) 11783 ioffset = convert_to_int(offset) 11784 keep_elem_refs(pObject, offset, ioffset) 11785 retval = _fl_set_formbrowser_yoffset(pObject, ioffset) 11786 return retval
11787 11788
11789 -def fl_get_formbrowser_xoffset(pObject):
11790 """ 11791 fl_get_formbrowser_xoffset(pObject) -> num. 11792 11793 Returns the current horizontal offset from left in pixel of a 11794 formbrowser. 11795 11796 @param pObject : pointer to formbrowser object 11797 """ 11798 11799 _fl_get_formbrowser_xoffset = cfuncproto( 11800 load_so_libforms(), "fl_get_formbrowser_xoffset", 11801 cty.c_int, [cty.POINTER(FL_OBJECT)], 11802 """int fl_get_formbrowser_xoffset(FL_OBJECT * ob) 11803 """) 11804 keep_elem_refs(pObject) 11805 retval = _fl_get_formbrowser_xoffset(pObject) 11806 return retval
11807 11808
11809 -def fl_get_formbrowser_yoffset(pObject):
11810 """ 11811 fl_get_formbrowser_yoffset(pObject) -> num. 11812 11813 Returns the current vertical offset from top in pixel of a 11814 formbrowser. 11815 11816 @param pObject : pointer to formbrowser object 11817 """ 11818 11819 _fl_get_formbrowser_yoffset = cfuncproto( 11820 load_so_libforms(), "fl_get_formbrowser_yoffset", 11821 cty.c_int, [cty.POINTER(FL_OBJECT)], 11822 """int fl_get_formbrowser_yoffset(FL_OBJECT * ob) 11823 """) 11824 keep_elem_refs(pObject) 11825 retval = _fl_get_formbrowser_yoffset(pObject) 11826 return retval
11827 11828
11829 -def fl_find_formbrowser_form_number(pObject, pFormCandidate):
11830 """ fl_find_formbrowser_form_number(pObject, pFormCandidate) -> num. 11831 """ 11832 11833 _fl_find_formbrowser_form_number = cfuncproto( 11834 load_so_libforms(), "fl_find_formbrowser_form_number", 11835 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_FORM)], 11836 """int fl_find_formbrowser_form_number(FL_OBJECT * ob, 11837 FL_FORM * candidate_form) 11838 """) 11839 keep_elem_refs(pObject, pFormCandidate) 11840 retval = _fl_find_formbrowser_form_number(pObject, pFormCandidate) 11841 return retval
11842 11843
11844 -def fl_add_formbrowser(frmbrwstype, x, y, w, h, label):
11845 """ fl_add_formbrowser(frmbrwstype, x, y, w, h, label) -> pObject 11846 """ 11847 11848 _fl_add_formbrowser = cfuncproto( 11849 load_so_libforms(), "fl_add_formbrowser", 11850 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, 11851 FL_Coord, FL_Coord, STRING], 11852 """FL_OBJECT * fl_add_formbrowser(int type, FL_Coord x, 11853 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 11854 """) 11855 check_admitted_listvalues(frmbrwstype, FORMBRWSTYPE_list) 11856 ifrmbrwstype = convert_to_int(frmbrwstype) 11857 ix = convert_to_FL_Coord(x) 11858 iy = convert_to_FL_Coord(y) 11859 iw = convert_to_FL_Coord(w) 11860 ih = convert_to_FL_Coord(h) 11861 slabel = convert_to_string(label) 11862 keep_elem_refs(frmbrwstype, x, y, w, h, label, ifrmbrwstype, ix, iy, 11863 iw, ih, slabel) 11864 retval = _fl_add_formbrowser(ifrmbrwstype, ix, iy, iw, ih, slabel) 11865 return retval
11866 11867
11868 -def fl_create_formbrowser(frmbrwstype, x, y, w, h, label):
11869 """ fl_create_formbrowser(frmbrwstype, x, y, w, h, label) -> pObject 11870 """ 11871 11872 _fl_create_formbrowser = cfuncproto( 11873 load_so_libforms(), "fl_create_formbrowser", 11874 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, 11875 FL_Coord, FL_Coord, STRING], 11876 """FL_OBJECT * fl_create_formbrowser(int type, FL_Coord x, 11877 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 11878 """) 11879 check_admitted_listvalues(frmbrwstype, FORMBRWSTYPE_list) 11880 ifrmbrwstype = convert_to_int(frmbrwstype) 11881 ix = convert_to_FL_Coord(x) 11882 iy = convert_to_FL_Coord(y) 11883 iw = convert_to_FL_Coord(w) 11884 ih = convert_to_FL_Coord(h) 11885 slabel = convert_to_string(label) 11886 keep_elem_refs(frmbrwstype, x, y, w, h, label, ifrmbrwstype, ix, iy, 11887 iw, ih, slabel) 11888 retval = _fl_create_formbrowser(ifrmbrwstype, ix, iy, iw, ih, slabel) 11889 return retval
11890 11891
11892 -def fl_get_formbrowser_numforms(pObject):
11893 """ fl_get_formbrowser_numforms(pObject) -> forms num. 11894 """ 11895 11896 _fl_get_formbrowser_numforms = cfuncproto( 11897 load_so_libforms(), "fl_get_formbrowser_numforms", 11898 cty.c_int, [cty.POINTER(FL_OBJECT)], 11899 """int fl_get_formbrowser_numforms(FL_OBJECT * ob) 11900 """) 11901 keep_elem_refs(pObject) 11902 retval = _fl_get_formbrowser_numforms(pObject) 11903 return retval
11904 11905
11906 -def fl_get_formbrowser_form(pObject, n):
11907 """ fl_get_formbrowser_form(pObject, n) -> pForm 11908 """ 11909 11910 _fl_get_formbrowser_form = cfuncproto( 11911 load_so_libforms(), "fl_get_formbrowser_form", 11912 cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT), cty.c_int], 11913 """FL_FORM * fl_get_formbrowser_form(FL_OBJECT * ob, int n) 11914 """) 11915 inum = convert_to_int(n) 11916 keep_elem_refs(pObject, n, inum) 11917 retval = _fl_get_formbrowser_form(pObject, inum) 11918 return retval
11919 11920 11921 11922 #################### 11923 # forms.h (frame.h) 11924 #################### 11925
11926 -def fl_create_frame(frametype, x, y, w, h, label):
11927 """ fl_create_frame(frametype, x, y, w, h, label) -> pObject 11928 """ 11929 11930 _fl_create_frame = cfuncproto( 11931 load_so_libforms(), "fl_create_frame", 11932 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 11933 FL_Coord, STRING], 11934 """FL_OBJECT * fl_create_frame(int type, FL_Coord x, FL_Coord y, 11935 FL_Coord w, FL_Coord h, const char * label) 11936 """) 11937 check_admitted_listvalues(frametype, FRAMETYPE_list) 11938 iframetype = convert_to_int(frametype) 11939 ix = convert_to_FL_Coord(x) 11940 iy = convert_to_FL_Coord(y) 11941 iw = convert_to_FL_Coord(w) 11942 ih = convert_to_FL_Coord(h) 11943 slabel = convert_to_string(label) 11944 keep_elem_refs(frametype, x, y, w, h, label, iframetype, ix, iy, 11945 iw, ih, slabel) 11946 retval = _fl_create_frame(iframetype, ix, iy, iw, ih, slabel) 11947 return retval
11948 11949
11950 -def fl_add_frame(frametype, x, y, w, h, label):
11951 """ fl_add_frame(frametype, x, y, w, h, label) -> pObject 11952 """ 11953 11954 _fl_add_frame = cfuncproto( 11955 load_so_libforms(), "fl_add_frame", 11956 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 11957 FL_Coord, STRING], 11958 """FL_OBJECT * fl_add_frame(int type, FL_Coord x, FL_Coord y, 11959 FL_Coord w, FL_Coord h, const char * label) 11960 """) 11961 check_admitted_listvalues(frametype, FRAMETYPE_list) 11962 iframetype = convert_to_int(frametype) 11963 ix = convert_to_FL_Coord(x) 11964 iy = convert_to_FL_Coord(y) 11965 iw = convert_to_FL_Coord(w) 11966 ih = convert_to_FL_Coord(h) 11967 slabel = convert_to_string(label) 11968 keep_elem_refs(frametype, x, y, w, h, label, iframetype, ix, iy, 11969 iw, ih, slabel) 11970 retval = _fl_add_frame(iframetype, ix, iy, iw, ih, slabel) 11971 return retval
11972 11973 11974 # labeld frame 11975
11976 -def fl_create_labelframe(frametype, x, y, w, h, label):
11977 """ fl_create_labelframe(frametype, x, y, w, h, label) -> pObject 11978 """ 11979 11980 _fl_create_labelframe = cfuncproto( 11981 load_so_libforms(), "fl_create_labelframe", 11982 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 11983 FL_Coord, STRING], 11984 """FL_OBJECT * fl_create_labelframe(int type, FL_Coord x, 11985 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 11986 """) 11987 iframetype = convert_to_int(frametype) 11988 ix = convert_to_FL_Coord(x) 11989 iy = convert_to_FL_Coord(y) 11990 iw = convert_to_FL_Coord(w) 11991 ih = convert_to_FL_Coord(h) 11992 slabel = convert_to_string(label) 11993 keep_elem_refs(frametype, x, y, w, h, label, iframetype, ix, iy, 11994 iw, ih, slabel) 11995 retval = _fl_create_labelframe(iframetype, ix, iy, iw, ih, slabel) 11996 return retval
11997 11998
11999 -def fl_add_labelframe(frametype, x, y, w, h, label):
12000 """ fl_add_labelframe(frametype, x, y, w, h, label) -> pObject 12001 """ 12002 12003 _fl_add_labelframe = cfuncproto( 12004 load_so_libforms(), "fl_add_labelframe", 12005 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 12006 FL_Coord, STRING], 12007 """FL_OBJECT * fl_add_labelframe(int type, FL_Coord x, FL_Coord y, 12008 FL_Coord w, FL_Coord h, const char * label) 12009 """) 12010 iframetype = convert_to_int(frametype) 12011 ix = convert_to_FL_Coord(x) 12012 iy = convert_to_FL_Coord(y) 12013 iw = convert_to_FL_Coord(w) 12014 ih = convert_to_FL_Coord(h) 12015 slabel = convert_to_string(label) 12016 keep_elem_refs(frametype, x, y, w, h, label, iframetype, ix, iy, 12017 iw, ih, slabel) 12018 retval = _fl_add_labelframe(iframetype, ix, iy, iw, ih, slabel) 12019 return retval
12020 12021 12022 12023 ##################### 12024 # forms.h (free.h) 12025 # Object Class: Free 12026 ##################### 12027
12028 -def fl_create_free(freetype, x, y, w, h, label, py_HandlePtr):
12029 """ fl_create_free(freetype, x, y, w, h, label, py_HandlePtr) -> pObject 12030 """ 12031 12032 _fl_create_free = cfuncproto( 12033 load_so_libforms(), "fl_create_free", 12034 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 12035 FL_Coord, STRING, FL_HANDLEPTR], 12036 """FL_OBJECT * fl_create_free(int type, FL_Coord x, FL_Coord y, 12037 FL_Coord w, FL_Coord h, const char * label, 12038 FL_HANDLEPTR handle) 12039 """) 12040 check_admitted_listvalues(freetype, FREETYPE_list) 12041 ifreetype = convert_to_int(freetype) 12042 ix = convert_to_FL_Coord(x) 12043 iy = convert_to_FL_Coord(y) 12044 iw = convert_to_FL_Coord(w) 12045 ih = convert_to_FL_Coord(h) 12046 slabel = convert_to_string(label) 12047 c_HandlePtr = FL_HANDLEPTR(py_HandlePtr) 12048 keep_cfunc_refs(c_HandlePtr, py_HandlePtr) 12049 keep_elem_refs(freetype, x, y, w, h, label, ifreetype, ix, iy, iw, ih, 12050 slabel) 12051 retval = _fl_create_free(ifreetype, ix, iy, iw, ih, slabel, c_HandlePtr) 12052 return retval
12053 12054
12055 -def fl_add_free(freetype, x, y, w, h, label, py_HandlePtr):
12056 """ fl_add_free(freetype, x, y, w, h, label, py_HandlePtr) -> pObject 12057 """ 12058 12059 _fl_add_free = cfuncproto( 12060 load_so_libforms(), "fl_add_free", 12061 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 12062 FL_Coord, STRING, FL_HANDLEPTR], 12063 """FL_OBJECT * fl_add_free(int type, FL_Coord x, FL_Coord y, 12064 FL_Coord w, FL_Coord h, const char * label, 12065 FL_HANDLEPTR handle) 12066 """) 12067 check_admitted_listvalues(freetype, FREETYPE_list) 12068 ifreetype = convert_to_int(freetype) 12069 ix = convert_to_FL_Coord(x) 12070 iy = convert_to_FL_Coord(y) 12071 iw = convert_to_FL_Coord(w) 12072 ih = convert_to_FL_Coord(h) 12073 slabel = convert_to_string(label) 12074 c_HandlePtr = FL_HANDLEPTR(py_HandlePtr) 12075 keep_cfunc_refs(c_HandlePtr, py_HandlePtr) 12076 keep_elem_refs(freetype, x, y, w, h, label, ifreetype, ix, iy, iw, ih, 12077 slabel) 12078 retval = _fl_add_free(ifreetype, ix, iy, iw, ih, slabel, c_HandlePtr) 12079 return retval
12080 12081 12082 12083 ###################### 12084 # forms.h (goodies.h) 12085 ###################### 12086 12087 # Resources and misc. goodie routines 12088
12089 -def fl_set_goodies_font(style, size):
12090 """ fl_set_goodies_font(style, size) 12091 """ 12092 12093 _fl_set_goodies_font = cfuncproto( 12094 load_so_libforms(), "fl_set_goodies_font", 12095 None, [cty.c_int, cty.c_int], 12096 """void fl_set_goodies_font(int style, int size) 12097 """) 12098 istyle = convert_to_int(style) 12099 isize = convert_to_int(size) 12100 keep_elem_refs(style, size, istyle, isize) 12101 _fl_set_goodies_font(istyle, isize)
12102 12103 12104 # messages and questions 12105
12106 -def fl_show_message(msgtxt1, msgtxt2, msgtxt3):
12107 """ 12108 fl_show_message(msgtxt1, msgtxt2, msgtxt3) 12109 12110 Shows a message. 12111 12112 @param msgtxt1 : first message to show 12113 @param msgtxt2 : second message to show 12114 @param msgtxt3 : third message to show 12115 """ 12116 12117 _fl_show_message = cfuncproto( 12118 load_so_libforms(), "fl_show_message", 12119 None, [STRING, STRING, STRING], 12120 """void fl_show_message(const char * p1, const char * p2, 12121 const char * p3) 12122 """) 12123 smsgtxt1 = convert_to_string(msgtxt1) 12124 smsgtxt2 = convert_to_string(msgtxt2) 12125 smsgtxt3 = convert_to_string(msgtxt3) 12126 keep_elem_refs(msgtxt1, msgtxt2, msgtxt3, smsgtxt1, smsgtxt2, smsgtxt3) 12127 _fl_show_message(smsgtxt1, smsgtxt2, smsgtxt3)
12128 12129
12130 -def fl_show_messages(p1):
12131 """ fl_show_messages(p1) 12132 """ 12133 12134 _fl_show_messages = cfuncproto( 12135 load_so_libforms(), "fl_show_messages", 12136 None, [STRING], 12137 """void fl_show_messages(const char * p1) 12138 """) 12139 sp1 = convert_to_string(p1) 12140 keep_elem_refs(p1, sp1) 12141 _fl_show_messages(sp1)
12142 12143
12144 -def fl_show_msg(fmttxt):
12145 """ 12146 fl_show_msg(fmttxt) 12147 12148 Shows a text message. 12149 12150 @param fmttxt : text message to show (with format parameters, e.g. 12151 %s, %d, %f etc..) 12152 """ 12153 12154 _fl_show_msg = cfuncproto( 12155 load_so_libforms(), "fl_show_msg", 12156 None, [STRING], 12157 """void fl_show_msg(const char * p1) 12158 """) 12159 sfmttxt = convert_to_string(fmttxt) 12160 keep_elem_refs(fmttxt, sfmttxt) 12161 _fl_show_msg(sfmttxt)
12162 12163
12164 -def fl_hide_message():
12165 """ 12166 fl_hide_message() 12167 12168 Hides a text message already shown. 12169 """ 12170 12171 _fl_hide_message = cfuncproto( 12172 load_so_libforms(), "fl_hide_message", 12173 None, [], 12174 """void fl_hide_message() 12175 """) 12176 _fl_hide_message()
12177 12178 12179 fl_hide_msg = fl_hide_message 12180 fl_hide_messages = fl_hide_message 12181 12182
12183 -def fl_show_question(questmsg, p2):
12184 """ 12185 fl_show_question(questmsg, p2) -> num. 12186 12187 Shows a question message. 12188 12189 @param questmsg : text of question message to show 12190 @param p2 : ? 12191 """ 12192 12193 _fl_show_question = cfuncproto( 12194 load_so_libforms(), "fl_show_question", 12195 cty.c_int, [STRING, cty.c_int], 12196 """int fl_show_question(const char * p1, int p2) 12197 """) 12198 squestmsg = convert_to_string(questmsg) 12199 ip2 = convert_to_int(p2) 12200 keep_elem_refs(questmsg, p2, squestmsg, ip2) 12201 retval = _fl_show_question(squestmsg, ip2) 12202 return retval
12203 12204
12205 -def fl_hide_question():
12206 """ 12207 fl_hide_question() 12208 12209 Hides a question message already shown. 12210 """ 12211 12212 _fl_hide_question = cfuncproto( 12213 load_so_libforms(), "fl_hide_question", 12214 None, [], 12215 """void fl_hide_question() 12216 """) 12217 _fl_hide_question()
12218 12219
12220 -def fl_show_alert(p1, p2, p3, p4):
12221 """ fl_show_alert(p1, p2, p3, p4) 12222 """ 12223 12224 _fl_show_alert = cfuncproto( 12225 load_so_libforms(), "fl_show_alert", 12226 None, [STRING, STRING, STRING, cty.c_int], 12227 """void fl_show_alert(const char * p1, const char * p2, 12228 const char * p3, int p4) 12229 """) 12230 sp1 = convert_to_string(p1) 12231 sp2 = convert_to_string(p2) 12232 sp3 = convert_to_string(p3) 12233 ip4 = convert_to_int(p4) 12234 keep_elem_refs(p1, p2, p3, p4, sp1, sp2, sp3, ip4) 12235 _fl_show_alert(sp1, sp2, sp3, ip4)
12236 12237
12238 -def fl_show_alert2(c, fmt):
12239 """ fl_show_alert2(c, fmt) 12240 """ 12241 12242 _fl_show_alert2 = cfuncproto( 12243 load_so_libforms(), "fl_show_alert2", 12244 None, [cty.c_int, STRING], 12245 """void fl_show_alert2(int c, const char * fmt) 12246 """) 12247 ic = convert_to_int(c) 12248 sfmt = convert_to_string(fmt) 12249 keep_elem_refs(c, fmt, ic, sfmt) 12250 _fl_show_alert2(ic, sfmt)
12251 12252
12253 -def fl_hide_alert():
12254 """ fl_hide_alert() 12255 """ 12256 12257 _fl_hide_alert = cfuncproto( 12258 load_so_libforms(), "fl_hide_alert", 12259 None, [], 12260 """void fl_hide_alert() 12261 """) 12262 _fl_hide_alert()
12263 12264
12265 -def fl_show_input(p1, p2):
12266 """ fl_show_input(p1, p2) -> input string 12267 """ 12268 12269 _fl_show_input = cfuncproto( 12270 load_so_libforms(), "fl_show_input", 12271 STRING, [STRING, STRING], 12272 """const char * fl_show_input(const char * p1, const char * p2) 12273 """) 12274 sp1 = convert_to_string(p1) 12275 sp2 = convert_to_string(p2) 12276 keep_elem_refs(p1, p2, sp1, sp2) 12277 retval = _fl_show_input(sp1, sp2) 12278 return retval
12279 12280
12281 -def fl_hide_input():
12282 """ fl_hide_input() 12283 """ 12284 12285 _fl_hide_input = cfuncproto( 12286 load_so_libforms(), "fl_hide_input", 12287 None, [], 12288 """void fl_hide_input() 12289 """) 12290 _fl_hide_input()
12291 12292
12293 -def fl_show_simple_input(msgtxt, defstr):
12294 """ 12295 fl_show_simple_input(msgtxt, defstr) -> input string 12296 12297 Asks the user for textual input. 12298 12299 @param msgtxt : text message 12300 @param defstr : default user answer in input 12301 """ 12302 12303 _fl_show_simple_input = cfuncproto( 12304 load_so_libforms(), "fl_show_simple_input", 12305 STRING, [STRING, STRING], 12306 """const char * fl_show_simple_input(const char * p1, 12307 const char * p2) 12308 """) 12309 smsgtxt = convert_to_string(msgtxt) 12310 sdefstr = convert_to_string(defstr) 12311 keep_elem_refs(msgtxt, defstr, smsgtxt, sdefstr) 12312 retval = _fl_show_simple_input(smsgtxt, sdefstr) 12313 return retval
12314 12315
12316 -def fl_show_colormap(oldcolr):
12317 """ fl_show_colormap(oldcolr) -> colormap num. 12318 Shows a colormap color selector from which the user can select a color. 12319 <oldcolr> : color num. 12320 """ 12321 12322 _fl_show_colormap = cfuncproto( 12323 load_so_libforms(), "fl_show_colormap", 12324 cty.c_int, [cty.c_int], 12325 """int fl_show_colormap(int p1) 12326 """) 12327 ioldcolr = convert_to_int(oldcolr) 12328 keep_elem_refs(oldcolr, ioldcolr) 12329 retval = _fl_show_colormap(ioldcolr) 12330 return retval
12331 12332 12333 # choices 12334
12335 -def fl_show_choices(p1, p2, p3, p4, p5, p6):
12336 """ fl_show_choices(p1, p2, p3, p4, p5, p6) -> num. 12337 """ 12338 12339 _fl_show_choices = cfuncproto( 12340 load_so_libforms(), "fl_show_choices", 12341 cty.c_int, [STRING, cty.c_int, STRING, STRING, STRING, 12342 cty.c_int], 12343 """int fl_show_choices(const char * p1, int p2, 12344 const char * p3, const char * p4, const char * p5, int p6) 12345 """) 12346 sp1 = convert_to_string(p1) 12347 ip2 = convert_to_int(p2) 12348 sp3 = convert_to_string(p3) 12349 sp4 = convert_to_string(p4) 12350 sp5 = convert_to_string(p5) 12351 ip6 = convert_to_int(p6) 12352 keep_elem_refs(p1, p2, p3, p4, p5, p6, sp1, ip2, sp3, sp4, sp5, ip6) 12353 retval = _fl_show_choices(sp1, ip2, sp3, sp4, sp5, ip6) 12354 return retval
12355 12356
12357 -def fl_show_choice(p1, p2, p3, p4, p5, p6, p7, p8):
12358 """ fl_show_choice(p1, p2, p3, p4, p5, p6, p7, p8) -> num. 12359 """ 12360 12361 _fl_show_choice = cfuncproto( 12362 load_so_libforms(), "fl_show_choice", 12363 cty.c_int, [STRING, STRING, STRING, cty.c_int, STRING, STRING, 12364 STRING, cty.c_int], 12365 """int fl_show_choice(const char * p1, const char * p2, 12366 const char * p3, int p4, const char * p5, const char * p6, 12367 const char * p7, int p8) 12368 """) 12369 sp1 = convert_to_string(p1) 12370 sp2 = convert_to_string(p2) 12371 sp3 = convert_to_string(p3) 12372 ip4 = convert_to_int(p4) 12373 sp5 = convert_to_string(p5) 12374 sp6 = convert_to_string(p6) 12375 sp7 = convert_to_string(p7) 12376 ip8 = convert_to_int(p8) 12377 keep_elem_refs(sp1, sp2, sp3, ip4, sp5, sp6, sp7, ip8) 12378 retval = _fl_show_choice(sp1, sp2, sp3, ip4, sp5, sp6, sp7, ip8) 12379 return retval
12380 12381
12382 -def fl_hide_choice():
12383 """ fl_hide_choice() 12384 """ 12385 12386 _fl_hide_choice = cfuncproto( 12387 load_so_libforms(), "fl_hide_choice", 12388 None, [], 12389 """void fl_hide_choice() 12390 """) 12391 _fl_hide_choice()
12392 12393
12394 -def fl_set_choices_shortcut(p1, p2, p3):
12395 """ fl_set_choices_shortcut(p1, p2, p3) 12396 """ 12397 12398 _fl_set_choices_shortcut = cfuncproto( 12399 load_so_libforms(), "fl_set_choices_shortcut", 12400 None, [STRING, STRING, STRING], 12401 """void fl_set_choices_shortcut(const char * p1, const char * p2, 12402 const char * p3) 12403 """) 12404 sp1 = convert_to_string(p1) 12405 sp2 = convert_to_string(p2) 12406 sp3 = convert_to_string(p3) 12407 keep_elem_refs(p1, p2, p3, sp1, sp2, sp3) 12408 _fl_set_choices_shortcut(sp1, sp2, sp3)
12409 12410 12411 fl_set_choice_shortcut = fl_set_choices_shortcut 12412 12413 12414 # one liner 12415
12416 -def fl_show_oneliner(p1, p2, p3):
12417 """ fl_show_oneliner(p1, p2, p3) 12418 """ 12419 12420 _fl_show_oneliner = cfuncproto( 12421 load_so_libforms(), "fl_show_oneliner", 12422 None, [STRING, FL_Coord, FL_Coord], 12423 """void fl_show_oneliner(const char * p1, FL_Coord p2, 12424 FL_Coord p3) 12425 """) 12426 sp1 = convert_to_string(p1) 12427 ip2 = convert_to_FL_Coord(p2) 12428 ip3 = convert_to_FL_Coord(p3) 12429 keep_elem_refs(p1, p2, p3, sp1, ip2, ip3) 12430 _fl_show_oneliner(sp1, ip2, ip3)
12431 12432
12433 -def fl_hide_oneliner():
12434 """ fl_hide_oneliner() 12435 """ 12436 12437 _fl_hide_oneliner = cfuncproto( 12438 load_so_libforms(), "fl_hide_oneliner", 12439 None, [], 12440 """void fl_hide_oneliner() 12441 """) 12442 _fl_hide_oneliner()
12443 12444
12445 -def fl_set_oneliner_font(p1, p2):
12446 """ fl_set_oneliner_font(p1, p2) 12447 """ 12448 12449 _fl_set_oneliner_font = cfuncproto( 12450 load_so_libforms(), "fl_set_oneliner_font", 12451 None, [cty.c_int, cty.c_int], 12452 """void fl_set_oneliner_font(int p1, int p2) 12453 """) 12454 ip1 = convert_to_int(p1) 12455 ip2 = convert_to_int(p2) 12456 keep_elem_refs(p1, p2, ip1, ip2) 12457 _fl_set_oneliner_font(ip1, ip2)
12458 12459
12460 -def fl_set_oneliner_color(p1, p2):
12461 """ fl_set_oneliner_color(p1, p2) 12462 """ 12463 12464 _fl_set_oneliner_color = cfuncproto( 12465 load_so_libforms(), "fl_set_oneliner_color", 12466 None, [FL_COLOR, FL_COLOR], 12467 """void fl_set_oneliner_color(FL_COLOR p1, FL_COLOR p2) 12468 """) 12469 ulp1 = convert_to_FL_COLOR(p1) 12470 ulp2 = convert_to_FL_COLOR(p2) 12471 keep_elem_refs(p1, p2, ulp1, ulp2) 12472 _fl_set_oneliner_color(ulp1, ulp2)
12473 12474
12475 -def fl_set_tooltip_font(p1, p2):
12476 """ fl_set_tooltip_font(p1, p2) 12477 """ 12478 12479 _fl_set_tooltip_font = cfuncproto( 12480 load_so_libforms(), "fl_set_tooltip_font", 12481 None, [cty.c_int, cty.c_int], 12482 """void fl_set_tooltip_font(int p1, int p2) 12483 """) 12484 ip1 = convert_to_int(p1) 12485 ip2 = convert_to_int(p2) 12486 keep_elem_refs(p1, p2, ip1, ip2) 12487 _fl_set_tooltip_font(ip1, ip2)
12488 12489
12490 -def fl_set_tooltip_color(p1, p2):
12491 """ fl_set_tooltip_color(p1, p2) 12492 """ 12493 12494 _fl_set_tooltip_color = cfuncproto( 12495 load_so_libforms(), "fl_set_tooltip_color", 12496 None, [FL_COLOR, FL_COLOR], 12497 """void fl_set_tooltip_color(FL_COLOR p1, FL_COLOR p2) 12498 """) 12499 ulp1 = convert_to_FL_COLOR(p1) 12500 ulp2 = convert_to_FL_COLOR(p2) 12501 keep_elem_refs(p1, p2, ulp1, ulp2) 12502 _fl_set_tooltip_color(ulp1, ulp2)
12503 12504
12505 -def fl_set_tooltip_boxtype(p1):
12506 """ fl_set_tooltip_boxtype(p1) 12507 """ 12508 12509 _fl_set_tooltip_boxtype = cfuncproto( 12510 load_so_libforms(), "fl_set_tooltip_boxtype", 12511 None, [cty.c_int], 12512 """void fl_set_tooltip_boxtype(int p1) 12513 """) 12514 ip1 = convert_to_int(p1) 12515 keep_elem_refs(p1, ip1) 12516 _fl_set_tooltip_boxtype(ip1)
12517 12518
12519 -def fl_set_tooltip_lalign(p1):
12520 """ fl_set_tooltip_lalign(p1) 12521 """ 12522 12523 _fl_set_tooltip_lalign = cfuncproto( 12524 load_so_libforms(), "fl_set_tooltip_lalign", 12525 None, [cty.c_int], 12526 """void fl_set_tooltip_lalign(int p1) 12527 """) 12528 ip1 = convert_to_int(p1) 12529 keep_elem_refs(p1, ip1) 12530 _fl_set_tooltip_lalign(ip1)
12531 12532
12533 -def fl_exe_command(p1, p2):
12534 """ fl_exe_command(p1, p2) -> num. 12535 """ 12536 12537 _fl_exe_command = cfuncproto( 12538 load_so_libforms(), "fl_exe_command", 12539 cty.c_long, [STRING, cty.c_int], 12540 """long int fl_exe_command(const char * p1, int p2) 12541 """) 12542 sp1 = convert_to_string(p1) 12543 ip2 = convert_to_int(p2) 12544 keep_elem_refs(p1, sp1, p2, ip2) 12545 retval = _fl_exe_command(sp1, ip2) 12546 return retval
12547 12548
12549 -def fl_end_command(p1):
12550 """ fl_end_command(p1) -> num. 12551 """ 12552 12553 _fl_end_command = cfuncproto( 12554 load_so_libforms(), "fl_end_command", 12555 cty.c_int, [cty.c_long], 12556 """int fl_end_command(long int p1) 12557 """) 12558 lp1 = convert_to_long(p1) 12559 keep_elem_refs(p1, lp1) 12560 retval = _fl_end_command(lp1) 12561 return retval
12562 12563
12564 -def fl_check_command(p1):
12565 """ fl_check_command(p1) -> num. 12566 """ 12567 12568 _fl_check_command = cfuncproto( 12569 load_so_libforms(), "fl_check_command", 12570 cty.c_int, [cty.c_long], 12571 """int fl_check_command(long int p1) 12572 """) 12573 lp1 = convert_to_long(p1) 12574 keep_elem_refs(p1, lp1) 12575 retval = _fl_check_command(lp1) 12576 return retval
12577 12578
12579 -def fl_popen(p1, p2):
12580 """ fl_popen(p1, p2) -> FILE ptr. 12581 """ 12582 12583 _fl_popen = cfuncproto( 12584 load_so_libforms(), "fl_popen", 12585 cty.POINTER(FILE), [STRING, STRING], 12586 """FILE * fl_popen(const char * p1, const char * p2) 12587 """) 12588 sp1 = convert_to_string(p1) 12589 sp2 = convert_to_string(p2) 12590 keep_elem_refs(p1, p2, sp1, sp2) 12591 retval = _fl_popen(sp1, sp2) 12592 return retval
12593 12594
12595 -def fl_pclose(p1):
12596 """ fl_pclose(p1) -> num. 12597 """ 12598 12599 _fl_pclose = cfuncproto( 12600 load_so_libforms(), "fl_pclose", 12601 cty.c_int, [cty.POINTER(FILE)], 12602 """int fl_pclose(FILE * p1) 12603 """) 12604 keep_elem_refs(p1) 12605 retval = _fl_pclose(p1) 12606 return retval
12607 12608
12609 -def fl_end_all_command():
12610 """ fl_end_all_command() -> num. 12611 """ 12612 12613 _fl_end_all_command = cfuncproto( 12614 load_so_libforms(), "fl_end_all_command", 12615 cty.c_int, [], 12616 """int fl_end_all_command() 12617 """) 12618 retval = _fl_end_all_command() 12619 return retval
12620 12621
12622 -def fl_show_command_log(p1):
12623 """ fl_show_command_log(p1) 12624 """ 12625 12626 _fl_show_command_log = cfuncproto( 12627 load_so_libforms(), "fl_show_command_log", 12628 None, [cty.c_int], 12629 """void fl_show_command_log(int p1) 12630 """) 12631 ip1 = convert_to_int(p1) 12632 keep_elem_refs(p1, ip1) 12633 _fl_show_command_log(ip1)
12634 12635
12636 -def fl_hide_command_log():
12637 """ fl_hide_command_log() 12638 """ 12639 12640 _fl_hide_command_log = cfuncproto( 12641 load_so_libforms(), "fl_hide_command_log", 12642 None, [], 12643 """void fl_hide_command_log() 12644 """) 12645 _fl_hide_command_log()
12646 12647
12648 -def fl_clear_command_log():
12649 """ fl_clear_command_log() 12650 """ 12651 12652 _fl_clear_command_log = cfuncproto( 12653 load_so_libforms(), "fl_clear_command_log", 12654 None, [], 12655 """void fl_clear_command_log() 12656 """) 12657 _fl_clear_command_log()
12658 12659
12660 -def fl_addto_command_log(p1):
12661 """ fl_addto_command_log(p1) 12662 """ 12663 12664 _fl_addto_command_log = cfuncproto( 12665 load_so_libforms(), "fl_addto_command_log", 12666 None, [STRING], 12667 """void fl_addto_command_log(const char * p1) 12668 """) 12669 sp1 = convert_to_string(p1) 12670 keep_elem_refs(p1, sp1) 12671 _fl_addto_command_log(sp1)
12672 12673
12674 -def fl_set_command_log_position(p1, p2):
12675 """ fl_set_command_log_position(p1, p2) 12676 """ 12677 12678 _fl_set_command_log_position = cfuncproto( 12679 load_so_libforms(), "fl_set_command_log_position", 12680 None, [cty.c_int, cty.c_int], 12681 """void fl_set_command_log_position(int p1, int p2) 12682 """) 12683 ip1 = convert_to_int(p1) 12684 ip2 = convert_to_int(p2) 12685 keep_elem_refs(p1, p2, ip1, ip2) 12686 _fl_set_command_log_position(ip1, ip2)
12687 12688
12689 -def fl_get_command_log_fdstruct():
12690 """ fl_get_command_log_fdstruct() -> pCmdlog 12691 """ 12692 12693 _fl_get_command_log_fdstruct = cfuncproto( 12694 load_so_libforms(), "fl_get_command_log_fdstruct", 12695 cty.POINTER(FD_CMDLOG), [], 12696 """)FD_CMDLOG * fl_get_command_log_fdstruct() 12697 """) 12698 retval = _fl_get_command_log_fdstruct() 12699 return retval
12700 12701 12702 # aliases 12703 fl_open_command = fl_exe_command 12704 fl_close_command = fl_end_command 12705 12706 12707 # file selector 12708
12709 -def fl_use_fselector(p1):
12710 """ fl_use_fselector(p1) -> num. 12711 """ 12712 12713 _fl_use_fselector = cfuncproto( 12714 load_so_libforms(), "fl_use_fselector", 12715 cty.c_int, [cty.c_int], 12716 """int fl_use_fselector(int p1) 12717 """) 12718 ip1 = convert_to_int(p1) 12719 keep_elem_refs(p1, ip1) 12720 retval = _fl_use_fselector(ip1) 12721 return retval
12722 12723
12724 -def fl_show_fselector(p1, p2, p3, p4):
12725 """ fl_show_fselector(p1, p2, p3, p4) -> fselector string 12726 """ 12727 12728 _fl_show_fselector = cfuncproto( 12729 load_so_libforms(), "fl_show_fselector", 12730 STRING, [STRING, STRING, STRING, STRING], 12731 """const char * fl_show_fselector(const char * p1, 12732 const char * p2, const char * p3, const char * p4) 12733 """) 12734 sp1 = convert_to_string(p1) 12735 sp2 = convert_to_string(p2) 12736 sp3 = convert_to_string(p3) 12737 sp4 = convert_to_string(p4) 12738 keep_elem_refs(p1, p2, p3, p4, sp1, sp2, sp3, sp4) 12739 retval = _fl_show_fselector(sp1, sp2, sp3, sp4) 12740 return retval
12741 12742
12743 -def fl_set_fselector_fontsize(p1):
12744 """ fl_set_fselector_fontsize(p1) 12745 """ 12746 12747 _fl_set_fselector_fontsize = cfuncproto( 12748 load_so_libforms(), "fl_set_fselector_fontsize", 12749 None, [cty.c_int], 12750 """void fl_set_fselector_fontsize(int p1) 12751 """) 12752 ip1 = convert_to_int(p1) 12753 keep_elem_refs(p1, ip1) 12754 _fl_set_fselector_fontsize(ip1)
12755 12756
12757 -def fl_set_fselector_fontstyle(p1):
12758 """ fl_set_fselector_fontstyle(p1) 12759 """ 12760 12761 _fl_set_fselector_fontstyle = cfuncproto( 12762 load_so_libforms(), "fl_set_fselector_fontstyle", 12763 None, [cty.c_int], 12764 """void fl_set_fselector_fontstyle(int p1) 12765 """) 12766 ip1 = convert_to_int(p1) 12767 keep_elem_refs(p1, ip1) 12768 _fl_set_fselector_fontstyle(ip1)
12769 12770
12771 -def fl_set_fselector_placement(p1):
12772 """ fl_set_fselector_placement(p1) 12773 """ 12774 12775 _fl_set_fselector_placement = cfuncproto( 12776 load_so_libforms(), "fl_set_fselector_placement", 12777 None, [cty.c_int], 12778 """void fl_set_fselector_placement(int p1) 12779 """) 12780 ip1 = convert_to_int(p1) 12781 keep_elem_refs(p1, ip1) 12782 _fl_set_fselector_placement(ip1)
12783 12784
12785 -def fl_set_fselector_border(p1):
12786 """ fl_set_fselector_border(p1) 12787 """ 12788 12789 _fl_set_fselector_border = cfuncproto( 12790 load_so_libforms(), "fl_set_fselector_border", 12791 None, [cty.c_int], 12792 """void fl_set_fselector_border(int p1) 12793 """) 12794 ip1 = convert_to_int(p1) 12795 keep_elem_refs(p1, ip1) 12796 _fl_set_fselector_border(ip1)
12797 12798
12799 -def fl_set_fselector_transient(b):
12800 if b: 12801 argval = FL_TRANSIENT 12802 else: 12803 argval = FL_FULLBORDER 12804 fl_set_fselector_border(argval)
12805 12806 12807 FL_FSCB = cty.CFUNCTYPE(cty.c_int, STRING, cty.c_void_p) 12808
12809 -def fl_set_fselector_callback(py_FSCB, data):
12810 """ 12811 fl_set_fselector_callback(py_FSCB, data) 12812 """ 12813 12814 _fl_set_fselector_callback = cfuncproto( 12815 load_so_libforms(), "fl_set_fselector_callback", 12816 None, [FL_FSCB, cty.c_void_p], 12817 """void fl_set_fselector_callback(FL_FSCB p1, void * p2) 12818 """) 12819 c_FSCB = FL_FSCB(py_FSCB) 12820 pdata = cty.cast(data, cty.c_void_p) 12821 keep_cfunc_refs(c_FSCB, py_FSCB) 12822 keep_elem_refs(data, pdata) 12823 _fl_set_fselector_callback(c_FSCB, pdata)
12824 12825
12826 -def fl_get_filename():
12827 """ fl_get_filename() -> filename string 12828 """ 12829 12830 _fl_get_filename = cfuncproto( 12831 load_so_libforms(), "fl_get_filename", 12832 STRING, [], 12833 """const char * fl_get_filename() 12834 """) 12835 retval = _fl_get_filename() 12836 return retval
12837 12838
12839 -def fl_get_directory():
12840 """ fl_get_directory() -> directory string 12841 """ 12842 12843 _fl_get_directory = cfuncproto( 12844 load_so_libforms(), "fl_get_directory", 12845 STRING, [], 12846 """const char * fl_get_directory() 12847 """) 12848 retval = _fl_get_directory() 12849 return retval
12850 12851
12852 -def fl_get_pattern():
12853 """ fl_get_pattern() -> pattern string 12854 """ 12855 12856 _fl_get_pattern = cfuncproto( 12857 load_so_libforms(), "fl_get_pattern", 12858 STRING, [], 12859 """const char * fl_get_pattern() 12860 """) 12861 retval = _fl_get_pattern() 12862 return retval
12863 12864
12865 -def fl_set_directory(p1):
12866 """ fl_set_directory(p1) -> num. 12867 """ 12868 12869 _fl_set_directory = cfuncproto( 12870 load_so_libforms(), "fl_set_directory", 12871 cty.c_int, [STRING], 12872 """int fl_set_directory(const char * p1) 12873 """) 12874 sp1 = convert_to_string(p1) 12875 keep_elem_refs(p1, sp1) 12876 retval = _fl_set_directory(sp1) 12877 return retval
12878 12879
12880 -def fl_set_pattern(p1):
12881 """ fl_set_pattern(p1) 12882 """ 12883 12884 _fl_set_pattern = cfuncproto( 12885 load_so_libforms(), "fl_set_pattern", 12886 None, [STRING], 12887 """void fl_set_pattern(const char * p1) 12888 """) 12889 sp1 = convert_to_string(p1) 12890 keep_elem_refs(p1, sp1) 12891 _fl_set_pattern(sp1)
12892 12893
12894 -def fl_refresh_fselector():
12895 """ fl_refresh_fselector() 12896 """ 12897 12898 _fl_refresh_fselector = cfuncproto( 12899 load_so_libforms(), "fl_refresh_fselector", 12900 None, [], 12901 """void fl_refresh_fselector() 12902 """) 12903 _fl_refresh_fselector()
12904 12905 12906 # c function prototype for _fl_add_fselector_appbutton 12907 cfunc_none_voidp = cty.CFUNCTYPE(None, cty.c_void_p) 12908
12909 -def fl_add_fselector_appbutton(label, py_fn, data):
12910 """ fl_add_fselector_appbutton(label, py_fn, data) 12911 """ 12912 12913 _fl_add_fselector_appbutton = cfuncproto( 12914 load_so_libforms(), "fl_add_fselector_appbutton", 12915 None, [STRING, cfunc_none_voidp, cty.c_void_p], 12916 """void fl_add_fselector_appbutton(const char * p1, 12917 const char * p2, void * p3) 12918 """) 12919 slabel = convert_to_string(label) 12920 c_fn = cfunc_none_voidp(py_fn) 12921 pdata = cty.cast(data, cty.c_void_p) 12922 keep_cfunc_refs(c_fn, py_fn) 12923 keep_elem_refs(label, data, slabel, pdata) 12924 _fl_add_fselector_appbutton(slabel, c_fn, pdata)
12925 12926
12927 -def fl_remove_fselector_appbutton(label):
12928 """ fl_remove_fselector_appbutton(label) 12929 """ 12930 12931 _fl_remove_fselector_appbutton = cfuncproto( 12932 load_so_libforms(), "fl_remove_fselector_appbutton", 12933 None, [STRING], 12934 """void fl_remove_fselector_appbutton(const char * p1) 12935 """) 12936 slabel = convert_to_string(label) 12937 keep_elem_refs(label, slabel) 12938 _fl_remove_fselector_appbutton(slabel)
12939 12940
12941 -def fl_disable_fselector_cache(yes):
12942 """ fl_disable_fselector_cache(yes) 12943 """ 12944 12945 _fl_disable_fselector_cache = cfuncproto( 12946 load_so_libforms(), "fl_disable_fselector_cache", 12947 None, [cty.c_int], 12948 """void fl_disable_fselector_cache(int p1) 12949 """) 12950 iyes = convert_to_int(yes) 12951 keep_elem_refs(yes, iyes) 12952 _fl_disable_fselector_cache(iyes)
12953 12954
12955 -def fl_invalidate_fselector_cache():
12956 """ fl_invalidate_fselector_cache() 12957 """ 12958 12959 _fl_invalidate_fselector_cache = cfuncproto( 12960 load_so_libforms(), "fl_invalidate_fselector_cache", 12961 None, [], 12962 """void fl_invalidate_fselector_cache() 12963 """) 12964 _fl_invalidate_fselector_cache()
12965 12966
12967 -def fl_get_fselector_form():
12968 """ fl_get_fselector_form() -> pForm 12969 """ 12970 12971 _fl_get_fselector_form = cfuncproto( 12972 load_so_libforms(), "fl_get_fselector_form", 12973 cty.POINTER(FL_FORM), [], 12974 """FL_FORM * fl_get_fselector_form() 12975 """) 12976 retval = _fl_get_fselector_form() 12977 return retval
12978 12979
12980 -def fl_get_fselector_fdstruct():
12981 """ fl_get_fselector_fdstruct() -> fselector class 12982 """ 12983 12984 _fl_get_fselector_fdstruct = cfuncproto( 12985 load_so_libforms(), "fl_get_fselector_fdstruct", 12986 cty.POINTER(FD_FSELECTOR), [], 12987 """FD_FSELECTOR * fl_get_fselector_fdstruct() 12988 """) 12989 retval = _fl_get_fselector_fdstruct() 12990 return retval
12991 12992
12993 -def fl_hide_fselector():
12994 """ fl_hide_fselector() 12995 """ 12996 12997 _fl_hide_fselector = cfuncproto( 12998 load_so_libforms(), "fl_hide_fselector", 12999 None, [], 13000 """void fl_hide_fselector() 13001 """) 13002 _fl_hide_fselector()
13003 13004
13005 -def fl_set_fselector_filetype_marker(p1, p2, p3, p4, p5):
13006 """ fl_set_fselector_filetype_marker(p1, p2, p3, p4, p5) 13007 """ 13008 13009 _fl_set_fselector_filetype_marker = cfuncproto( 13010 load_so_libforms(), "fl_set_fselector_filetype_marker", 13011 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int], 13012 """void fl_set_fselector_filetype_marker(int p1, int p2, int p3, 13013 int p4, int p5) 13014 """) 13015 ip1 = convert_to_int(p1) 13016 ip2 = convert_to_int(p2) 13017 ip3 = convert_to_int(p3) 13018 ip4 = convert_to_int(p4) 13019 ip5 = convert_to_int(p5) 13020 keep_elem_refs(p1, p2, p3, p4, p5, ip1, ip2, ip3, ip4, ip5) 13021 _fl_set_fselector_filetype_marker(ip1, ip2, ip3, ip4, ip5)
13022 13023 13024 fl_show_file_selector = fl_show_fselector 13025 fl_set_fselector_cb = fl_set_fselector_callback 13026 13027
13028 -def fl_set_fselector_title(title):
13029 fl_set_form_title(fl_get_fselector_form(), title)
13030 13031
13032 -def fl_goodies_atclose(pForm, data):
13033 """ fl_goodies_atclose(pForm, data) -> num. 13034 """ 13035 13036 _fl_goodies_atclose = cfuncproto( 13037 load_so_libforms(), "fl_goodies_atclose", 13038 cty.c_int, [cty.POINTER(FL_FORM), cty.c_void_p], 13039 """int fl_goodies_atclose(FL_FORM * p1, void * p2) 13040 """) 13041 pdata = cty.cast(data, cty.c_void_p) 13042 keep_elem_refs(pForm, data, pdata) 13043 retval = _fl_goodies_atclose(pForm, pdata) 13044 return retval
13045 13046 13047 13048 #################### 13049 # forms.h (input.h) 13050 #################### 13051 13052 # Routines 13053
13054 -def fl_create_input(inputtype, x, y, w, h, label):
13055 """ fl_create_input(inputtype, x, y, w, h, label) -> pObject 13056 """ 13057 13058 _fl_create_input = cfuncproto( 13059 load_so_libforms(), "fl_create_input", 13060 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 13061 FL_Coord, STRING], 13062 """FL_OBJECT * fl_create_input(int type, FL_Coord x, FL_Coord y, 13063 FL_Coord w, FL_Coord h, const char * label) 13064 """) 13065 check_admitted_listvalues(inputtype, INPUTTYPE_list) 13066 iinputtype = convert_to_int(inputtype) 13067 ix = convert_to_FL_Coord(x) 13068 iy = convert_to_FL_Coord(y) 13069 iw = convert_to_FL_Coord(w) 13070 ih = convert_to_FL_Coord(h) 13071 slabel = convert_to_string(label) 13072 keep_elem_refs(inputtype, x, y, w, h, label, iinputtype, ix, iy, 13073 iw, ih, slabel) 13074 retval = _fl_create_input(iinputtype, ix, iy, iw, ih, slabel) 13075 return retval
13076 13077
13078 -def fl_add_input(inputtype, x, y, w, h, label):
13079 """ fl_add_input(inputtype, x, y, w, h, label) -> pObject 13080 """ 13081 13082 _fl_add_input = cfuncproto( 13083 load_so_libforms(), "fl_add_input", 13084 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 13085 FL_Coord, STRING], 13086 """FL_OBJECT * fl_add_input(int type, FL_Coord x, FL_Coord y, 13087 FL_Coord w, FL_Coord h, const char * label) 13088 """) 13089 check_admitted_listvalues(inputtype, INPUTTYPE_list) 13090 iinputtype = convert_to_int(inputtype) 13091 ix = convert_to_FL_Coord(x) 13092 iy = convert_to_FL_Coord(y) 13093 iw = convert_to_FL_Coord(w) 13094 ih = convert_to_FL_Coord(h) 13095 slabel = convert_to_string(label) 13096 keep_elem_refs(inputtype, x, y, w, h, label, iinputtype, ix, iy, 13097 iw, ih, slabel) 13098 retval = _fl_add_input(iinputtype, ix, iy, iw, ih, slabel) 13099 return retval
13100 13101
13102 -def fl_set_input(pObject, inputstr):
13103 """ fl_set_input(pObject, inputstr) 13104 """ 13105 13106 _fl_set_input = cfuncproto( 13107 load_so_libforms(), "fl_set_input", 13108 None, [cty.POINTER(FL_OBJECT), STRING], 13109 """void fl_set_input(FL_OBJECT * ob, const char * str) 13110 """) 13111 sinputstr = convert_to_string(inputstr) 13112 keep_elem_refs(pObject, inputstr, sinputstr) 13113 _fl_set_input(pObject, sinputstr)
13114 13115
13116 -def fl_set_input_return(pObject, value):
13117 """ fl_set_input_return(pObject, value) 13118 """ 13119 13120 _fl_set_input_return = cfuncproto( 13121 load_so_libforms(), "fl_set_input_return", 13122 None, [cty.POINTER(FL_OBJECT), cty.c_int], 13123 """void fl_set_input_return(FL_OBJECT * ob, int value) 13124 """) 13125 ivalue = convert_to_int(value) 13126 keep_elem_refs(pObject, value, ivalue) 13127 _fl_set_input_return(pObject, ivalue)
13128 13129
13130 -def fl_set_input_color(pObject, textcolr, curscolr):
13131 """ fl_set_input_color(pObject, textcolr, curscolr) 13132 """ 13133 13134 _fl_set_input_color = cfuncproto( 13135 load_so_libforms(), "fl_set_input_color", 13136 None, [cty.POINTER(FL_OBJECT), FL_COLOR, FL_COLOR], 13137 """void fl_set_input_color(FL_OBJECT * ob, FL_COLOR textcol, 13138 FL_COLOR curscol) 13139 """) 13140 ultextcolr = convert_to_FL_COLOR(textcolr) 13141 ulcurscolr = convert_to_FL_COLOR(curscolr) 13142 keep_elem_refs(pObject, textcolr, curscolr, ultextcolr, ulcurscolr) 13143 _fl_set_input_color(pObject, ultextcolr, ulcurscolr)
13144 13145 13146 #def fl_get_input_color(pObject, textcolr, curscolr) *API change*
13147 -def fl_get_input_color(pObject):
13148 """ fl_get_input_color(pObject) -> textcolr, curscolr 13149 """ 13150 13151 _fl_get_input_color = cfuncproto( 13152 load_so_libforms(), "fl_get_input_color", 13153 None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_COLOR), 13154 cty.POINTER(FL_COLOR)], 13155 """void fl_get_input_color(FL_OBJECT * ob, FL_COLOR * textcol, 13156 FL_COLOR * curscol) 13157 """) 13158 textcolr, ptextcolr = make_ulong_and_pointer() 13159 curscolr, pcurscolr = make_ulong_and_pointer() 13160 keep_elem_refs(pObject, textcolr, curscolr) 13161 _fl_get_input_color(pObject, ptextcolr, pcurscolr) 13162 return textcolr, curscolr
13163 13164
13165 -def fl_set_input_scroll(pObject, yes):
13166 """ fl_set_input_scroll(pObject, yes) 13167 """ 13168 13169 _fl_set_input_scroll = cfuncproto( 13170 load_so_libforms(), "fl_set_input_scroll", 13171 None, [cty.POINTER(FL_OBJECT), cty.c_int], 13172 """void fl_set_input_scroll(FL_OBJECT * ob, int yes) 13173 """) 13174 iyes = convert_to_int(yes) 13175 keep_elem_refs(pObject, yes, iyes) 13176 _fl_set_input_scroll(pObject, iyes)
13177 13178
13179 -def fl_set_input_cursorpos(pObject, xpos, ypos):
13180 """ fl_set_input_cursorpos(pObject, xpos, ypos) 13181 """ 13182 13183 _fl_set_input_cursorpos = cfuncproto( 13184 load_so_libforms(), "fl_set_input_cursorpos", 13185 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 13186 """void fl_set_input_cursorpos(FL_OBJECT * ob, int xpos, int ypos) 13187 """) 13188 ixpos = convert_to_int(xpos) 13189 iypos = convert_to_int(ypos) 13190 keep_elem_refs(pObject, xpos, ypos, ixpos, iypos) 13191 _fl_set_input_cursorpos(pObject, ixpos, iypos)
13192 13193
13194 -def fl_set_input_selected(pObject, yes):
13195 """ fl_set_input_selected(pObject, yes) 13196 """ 13197 13198 _fl_set_input_selected = cfuncproto( 13199 load_so_libforms(), "fl_set_input_selected", 13200 None, [cty.POINTER(FL_OBJECT), cty.c_int], 13201 """void fl_set_input_selected(FL_OBJECT * ob, int yes) 13202 """) 13203 iyes = convert_to_int(yes) 13204 keep_elem_refs(pObject, yes, iyes) 13205 _fl_set_input_selected(pObject, iyes)
13206 13207
13208 -def fl_set_input_selected_range(pObject, begin, end):
13209 """ fl_set_input_selected_range(pObject, begin, end) 13210 """ 13211 13212 _fl_set_input_selected_range = cfuncproto( 13213 load_so_libforms(), "fl_set_input_selected_range", 13214 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 13215 """void fl_set_input_selected_range(FL_OBJECT * ob, 13216 int begin, int end) 13217 """) 13218 ibegin = convert_to_int(begin) 13219 iend = convert_to_int(end) 13220 keep_elem_refs(pObject, begin, end, ibegin, iend) 13221 _fl_set_input_selected_range(pObject, ibegin, iend)
13222 13223 13224 #def fl_get_input_selected_range(pObject, begin, end) *API change*
13225 -def fl_get_input_selected_range(pObject):
13226 """ fl_get_input_selected_range(pObject) -> string, begin, end 13227 """ 13228 13229 _fl_get_input_selected_range = cfuncproto( 13230 load_so_libforms(), "fl_get_input_selected_range", 13231 STRING, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 13232 cty.POINTER(cty.c_int)], 13233 """const char * fl_get_input_selected_range(FL_OBJECT * ob, 13234 int * begin, int * end) 13235 """) 13236 begin, pbegin = make_int_and_pointer() 13237 end, pend = make_int_and_pointer() 13238 keep_elem_refs(pObject, begin, end, pbegin, pend) 13239 retval = _fl_get_input_selected_range(pObject, pbegin, pend) 13240 return retval, begin, end
13241 13242
13243 -def fl_set_input_maxchars(pObject, maxchars):
13244 """ fl_set_input_maxchars(pObject, maxchars) 13245 """ 13246 13247 _fl_set_input_maxchars = cfuncproto( 13248 load_so_libforms(), "fl_set_input_maxchars", 13249 None, [cty.POINTER(FL_OBJECT), cty.c_int], 13250 """void fl_set_input_maxchars(FL_OBJECT * ob, int maxchars) 13251 """) 13252 imaxchars = convert_to_int(maxchars) 13253 keep_elem_refs(pObject, maxchars, imaxchars) 13254 _fl_set_input_maxchars(pObject, imaxchars)
13255 13256
13257 -def fl_set_input_format(pObject, fmt, sep):
13258 """ fl_set_input_format(pObject, fmt, sep) 13259 """ 13260 13261 _fl_set_input_format = cfuncproto( 13262 load_so_libforms(), "fl_set_input_format", 13263 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 13264 """void fl_set_input_format(FL_OBJECT * ob, int fmt, int sep) 13265 """) 13266 ifmt = convert_to_int(fmt) 13267 isep = convert_to_int(sep) 13268 keep_elem_refs(pObject, fmt, sep, ifmt, isep) 13269 _fl_set_input_format(pObject, ifmt, isep)
13270 13271
13272 -def fl_set_input_hscrollbar(pObject, pref):
13273 """ fl_set_input_hscrollbar(pObject, pref) 13274 """ 13275 13276 _fl_set_input_hscrollbar = cfuncproto( 13277 load_so_libforms(), "fl_set_input_hscrollbar", 13278 None, [cty.POINTER(FL_OBJECT), cty.c_int], 13279 """void fl_set_input_hscrollbar(FL_OBJECT * ob, int pref) 13280 """) 13281 ipref = convert_to_int(pref) 13282 keep_elem_refs(pObject, pref, ipref) 13283 _fl_set_input_hscrollbar(pObject, ipref)
13284 13285
13286 -def fl_set_input_vscrollbar(pObject, pref):
13287 """ fl_set_input_vscrollbar(pObject, pref) 13288 """ 13289 13290 _fl_set_input_vscrollbar = cfuncproto( 13291 load_so_libforms(), "fl_set_input_vscrollbar", 13292 None, [cty.POINTER(FL_OBJECT), cty.c_int], 13293 """void fl_set_input_vscrollbar(FL_OBJECT * ob, int pref) 13294 """) 13295 ipref = convert_to_int(pref) 13296 keep_elem_refs(pObject, pref, ipref) 13297 _fl_set_input_vscrollbar(pObject, ipref)
13298 13299
13300 -def fl_set_input_topline(pObject, top):
13301 """ fl_set_input_topline(pObject, top) 13302 """ 13303 13304 _fl_set_input_topline = cfuncproto( 13305 load_so_libforms(), "fl_set_input_topline", 13306 None, [cty.POINTER(FL_OBJECT), cty.c_int], 13307 """void fl_set_input_topline(FL_OBJECT * ob, int top) 13308 """) 13309 itop = convert_to_int(top) 13310 keep_elem_refs(pObject, top, itop) 13311 _fl_set_input_topline(pObject, itop)
13312 13313
13314 -def fl_set_input_scrollbarsize(pObject, hh, vw):
13315 """ fl_set_input_scrollbarsize(pObject, hh, vw) 13316 """ 13317 13318 _fl_set_input_scrollbarsize = cfuncproto( 13319 load_so_libforms(), "fl_set_input_scrollbarsize", 13320 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 13321 """void fl_set_input_scrollbarsize(FL_OBJECT * ob, int hh, int vw) 13322 """) 13323 ihh = convert_to_int(hh) 13324 ivw = convert_to_int(vw) 13325 keep_elem_refs(pObject, hh, vw, ihh, ivw) 13326 _fl_set_input_scrollbarsize(pObject, ihh, ivw)
13327 13328 13329 #def fl_get_input_scrollbarsize(pObject, hh, vw) *API change*
13330 -def fl_get_input_scrollbarsize(pObject):
13331 """ fl_get_input_scrollbarsize(pObject) -> hh, vw 13332 """ 13333 13334 _fl_get_input_scrollbarsize = cfuncproto( 13335 load_so_libforms(), "fl_get_input_scrollbarsize", 13336 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 13337 cty.POINTER(cty.c_int)], 13338 """void fl_get_input_scrollbarsize(FL_OBJECT * ob, 13339 int * hh, int * vw) 13340 """) 13341 hh, phh = make_int_and_pointer() 13342 vw, pvw = make_int_and_pointer() 13343 keep_elem_refs(pObject, hh, vw) 13344 _fl_get_input_scrollbarsize(pObject, phh, pvw) 13345 return hh, vw
13346 13347
13348 -def fl_set_input_xoffset(pObject, xoff):
13349 """ fl_set_input_xoffset(pObject, xoff) 13350 """ 13351 13352 _fl_set_input_xoffset = cfuncproto( 13353 load_so_libforms(), "fl_set_input_xoffset", 13354 None, [cty.POINTER(FL_OBJECT), cty.c_int], 13355 """void fl_set_input_xoffset(FL_OBJECT * ob, int xoff) 13356 """) 13357 ixoff = convert_to_int(xoff) 13358 keep_elem_refs(pObject, xoff, ixoff) 13359 _fl_set_input_xoffset(pObject, ixoff)
13360 13361
13362 -def fl_get_input_xoffset(pObject):
13363 """ fl_get_input_xoffset(pObject) -> num. 13364 """ 13365 13366 _fl_get_input_xoffset = cfuncproto( 13367 load_so_libforms(), "fl_get_input_xoffset", 13368 cty.c_int, [cty.POINTER(FL_OBJECT)], 13369 """int fl_get_input_xoffset(FL_OBJECT * ob) 13370 """) 13371 keep_elem_refs(pObject) 13372 retval = _fl_get_input_xoffset(pObject) 13373 return retval
13374 13375
13376 -def fl_set_input_fieldchar(pObject, fldchar):
13377 """ fl_set_input_fieldchar(pObject, fldchar) -> num. 13378 """ 13379 13380 _fl_set_input_fieldchar = cfuncproto( 13381 load_so_libforms(), "fl_set_input_fieldchar", 13382 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 13383 """int fl_set_input_fieldchar(FL_OBJECT * ob, int fchar) 13384 """) 13385 ifldchar = convert_to_int(fldchar) 13386 keep_elem_refs(pObject, fldchar, ifldchar) 13387 retval = _fl_set_input_fieldchar(pObject, ifldchar) 13388 return retval
13389 13390
13391 -def fl_get_input_topline(pObject):
13392 """ fl_get_input_topline(pObject) -> num. 13393 """ 13394 13395 _fl_get_input_topline = cfuncproto( 13396 load_so_libforms(), "fl_get_input_topline", 13397 cty.c_int, [cty.POINTER(FL_OBJECT)], 13398 """int fl_get_input_topline(FL_OBJECT * ob) 13399 """) 13400 keep_elem_refs(pObject) 13401 retval = _fl_get_input_topline(pObject) 13402 return retval
13403 13404
13405 -def fl_get_input_screenlines(pObject):
13406 """ fl_get_input_screenlines(pObject) -> num. 13407 """ 13408 13409 _fl_get_input_screenlines = cfuncproto( 13410 load_so_libforms(), "fl_get_input_screenlines", 13411 cty.c_int, [cty.POINTER(FL_OBJECT)], 13412 """int fl_get_input_screenlines(FL_OBJECT * ob) 13413 """) 13414 keep_elem_refs(pObject) 13415 retval = _fl_get_input_screenlines(pObject) 13416 return retval
13417 13418 13419 #def fl_get_input_cursorpos(pObject, x, y) *API change*
13420 -def fl_get_input_cursorpos(pObject):
13421 """ fl_get_input_cursorpos(pObject) -> num., x, y 13422 """ 13423 13424 _fl_get_input_cursorpos = cfuncproto( 13425 load_so_libforms(), "fl_get_input_cursorpos", 13426 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 13427 cty.POINTER(cty.c_int)], 13428 """int fl_get_input_cursorpos(FL_OBJECT * ob, int * x, int * y) 13429 """) 13430 x, px = make_int_and_pointer() 13431 y, py = make_int_and_pointer() 13432 keep_elem_refs(pObject, x, y) 13433 retval = _fl_get_input_cursorpos(pObject, px, py) 13434 return retval, x, y
13435 13436
13437 -def fl_set_input_cursor_visible(pObject, visible):
13438 """ fl_set_input_cursor_visible(pObject, visible) 13439 """ 13440 13441 _fl_set_input_cursor_visible = cfuncproto( 13442 load_so_libforms(), "fl_set_input_cursor_visible", 13443 None, [cty.POINTER(FL_OBJECT), cty.c_int], 13444 """void fl_set_input_cursor_visible(FL_OBJECT * ob, int visible) 13445 """) 13446 ivisible = convert_to_int(visible) 13447 keep_elem_refs(pObject, visible, ivisible) 13448 _fl_set_input_cursor_visible(pObject, ivisible)
13449 13450
13451 -def fl_get_input_numberoflines(pObject):
13452 """ fl_get_input_numberoflines(pObject) -> lines num. 13453 """ 13454 13455 _fl_get_input_numberoflines = cfuncproto( 13456 load_so_libforms(), "fl_get_input_numberoflines", 13457 cty.c_int, [cty.POINTER(FL_OBJECT)], 13458 """int fl_get_input_numberoflines(FL_OBJECT * ob) 13459 """) 13460 keep_elem_refs(pObject) 13461 retval = _fl_get_input_numberoflines(pObject) 13462 return retval
13463 13464 13465 #def fl_get_input_format(pObject, fmt, sep) *API change*
13466 -def fl_get_input_format(pObject):
13467 """ fl_get_input_format(pObject) -> fmt, sep 13468 """ 13469 13470 _fl_get_input_format = cfuncproto( 13471 load_so_libforms(), "fl_get_input_format", 13472 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 13473 cty.POINTER(cty.c_int)], 13474 """void fl_get_input_format(FL_OBJECT * ob, int * fmt, int * sep) 13475 """) 13476 fmt, pfmt = make_int_and_pointer() 13477 sep, psep = make_int_and_pointer() 13478 keep_elem_refs(pObject, fmt, sep, pfmt, psep) 13479 _fl_get_input_format(pObject, pfmt, psep) 13480 return fmt, sep
13481 13482
13483 -def fl_get_input(pObject):
13484 """ fl_get_input(pObject) -> input string 13485 """ 13486 13487 _fl_get_input = cfuncproto( 13488 load_so_libforms(), "fl_get_input", 13489 STRING, [cty.POINTER(FL_OBJECT)], 13490 """const char * fl_get_input(FL_OBJECT * ob) 13491 """) 13492 keep_elem_refs(pObject) 13493 retval = _fl_get_input(pObject) 13494 return retval
13495 13496 13497 FL_INPUTVALIDATOR = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_OBJECT), STRING, 13498 STRING, cty.c_int) 13499
13500 -def fl_set_input_filter(pObject, py_InputValidator):
13501 """ 13502 fl_set_input_filter(pObject, py_InputValidator) -> input_filter func. 13503 """ 13504 13505 _fl_set_input_filter = cfuncproto( 13506 load_so_libforms(), "fl_set_input_filter", 13507 FL_INPUTVALIDATOR, [cty.POINTER(FL_OBJECT), FL_INPUTVALIDATOR], 13508 """FL_INPUTVALIDATOR fl_set_input_filter(FL_OBJECT * ob, 13509 FL_INPUTVALIDATOR validate) 13510 """) 13511 c_InputValidator = FL_INPUTVALIDATOR(py_InputValidator) 13512 keep_cfunc_refs(c_InputValidator, py_InputValidator) 13513 keep_elem_refs(pObject) 13514 retval = _fl_set_input_filter(pObject, c_InputValidator) 13515 return retval
13516 13517
13518 -def fl_validate_input(pObject):
13519 """ fl_validate_input(pObject) -> num. 13520 """ 13521 13522 _fl_validate_input = cfuncproto( 13523 load_so_libforms(), "fl_validate_input", 13524 cty.c_int, [cty.POINTER(FL_OBJECT)], 13525 """int fl_validate_input(FL_OBJECT * obj) 13526 """) 13527 keep_elem_refs(pObject) 13528 retval = _fl_validate_input(pObject) 13529 return retval
13530 13531 13532 fl_set_input_shortcut = fl_set_object_shortcut 13533 13534 13535 # edit keys 13536
13537 -def fl_set_input_editkeymap(pEditKeymap):
13538 """ fl_set_input_editkeymap(pEditKeymap) 13539 """ 13540 13541 _fl_set_input_editkeymap = cfuncproto( 13542 load_so_libforms(), "fl_set_input_editkeymap", 13543 None, [cty.POINTER(FL_EditKeymap)], 13544 """void fl_set_input_editkeymap(const char * keymap) 13545 """) 13546 keep_elem_refs(pEditKeymap) 13547 _fl_set_input_editkeymap(pEditKeymap)
13548 13549 13550 13551 ##################### 13552 # forms.h (menu.h) 13553 # Object Class: Menu 13554 ##################### 13555 13556 # Routines 13557
13558 -def fl_create_menu(menutype, x, y, w, h, label):
13559 """ fl_create_menu(menutype, x, y, w, h, label) -> pObject 13560 """ 13561 13562 _fl_create_menu = cfuncproto( 13563 load_so_libforms(), "fl_create_menu", 13564 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 13565 FL_Coord, STRING], 13566 """FL_OBJECT * fl_create_menu(int type, FL_Coord x, FL_Coord y, 13567 FL_Coord w, FL_Coord h, const char * label) 13568 """) 13569 check_admitted_listvalues(menutype, MENUTYPE_list) 13570 imenutype = convert_to_int(menutype) 13571 ix = convert_to_FL_Coord(x) 13572 iy = convert_to_FL_Coord(y) 13573 iw = convert_to_FL_Coord(w) 13574 ih = convert_to_FL_Coord(h) 13575 slabel = convert_to_string(label) 13576 keep_elem_refs(menutype, x, y, w, h, label, imenutype, ix, iy, 13577 iw, ih, slabel) 13578 retval = _fl_create_menu(imenutype, ix, iy, iw, ih, slabel) 13579 return retval
13580 13581
13582 -def fl_add_menu(menutype, x, y, w, h, label):
13583 """ fl_add_menu(menutype, x, y, w, h, label) -> pObject 13584 """ 13585 13586 _fl_add_menu = cfuncproto( 13587 load_so_libforms(), "fl_add_menu", 13588 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 13589 FL_Coord, STRING], 13590 """FL_OBJECT * fl_add_menu(int type, FL_Coord x, FL_Coord y, 13591 FL_Coord w, FL_Coord h, const char * label) DEPRECATED 13592 """) 13593 check_admitted_listvalues(menutype, MENUTYPE_list) 13594 imenutype = convert_to_int(menutype) 13595 ix = convert_to_FL_Coord(x) 13596 iy = convert_to_FL_Coord(y) 13597 iw = convert_to_FL_Coord(w) 13598 ih = convert_to_FL_Coord(h) 13599 slabel = convert_to_string(label) 13600 keep_elem_refs(menutype, x, y, w, h, label, imenutype, ix, iy, 13601 iw, ih, slabel) 13602 retval = _fl_add_menu(imenutype, ix, iy, iw, ih, slabel) 13603 return retval
13604 13605
13606 -def fl_clear_menu(pObject):
13607 """ fl_clear_menu(pObject) 13608 """ 13609 13610 _fl_clear_menu = cfuncproto( 13611 load_so_libforms(), "fl_clear_menu", 13612 None, [cty.POINTER(FL_OBJECT)], 13613 """void fl_clear_menu(FL_OBJECT * ob) DEPRECATED 13614 """) 13615 keep_elem_refs(pObject) 13616 _fl_clear_menu(pObject)
13617 13618
13619 -def fl_set_menu(pObject, menustr):
13620 """ 13621 fl_set_menu(pObject, menustr) 13622 13623 Sets the menu to a particular menu string. 13624 13625 @param pObject : pointer to menu object 13626 @param menustr : text string of menu 13627 """ 13628 13629 _fl_set_menu = cfuncproto( 13630 load_so_libforms(), "fl_set_menu", 13631 None, [cty.POINTER(FL_OBJECT), STRING], 13632 """void fl_set_menu(FL_OBJECT * ob, const char * menustr) DEPRECATED 13633 """) 13634 smenustr = convert_to_string(menustr) 13635 keep_elem_refs(pObject, menustr, smenustr) 13636 _fl_set_menu(pObject, smenustr)
13637 13638
13639 -def fl_addto_menu(pObject, menustr):
13640 """ fl_addto_menu(pObject, menustr) -> num. 13641 """ 13642 13643 _fl_addto_menu = cfuncproto( 13644 load_so_libforms(), "fl_addto_menu", 13645 cty.c_int, [cty.POINTER(FL_OBJECT), STRING], 13646 """int fl_addto_menu(FL_OBJECT * ob, const char * menustr) DEPRECATED 13647 """) 13648 smenustr = convert_to_string(menustr) 13649 keep_elem_refs(pObject, menustr, smenustr) 13650 retval = _fl_addto_menu(pObject, smenustr) 13651 return retval
13652 13653
13654 -def fl_replace_menu_item(pObject, numb, itemstr):
13655 """ fl_replace_menu_item(pObject, numb, itemstr) 13656 """ 13657 13658 _fl_replace_menu_item = cfuncproto( 13659 load_so_libforms(), "fl_replace_menu_item", 13660 None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 13661 """void fl_replace_menu_item(FL_OBJECT * ob, int numb, 13662 const char * str) DEPRECATED 13663 """) 13664 inumb = convert_to_int(numb) 13665 sitemstr = convert_to_string(itemstr) 13666 keep_elem_refs(pObject, numb, itemstr, inumb, sitemstr) 13667 _fl_replace_menu_item(pObject, inumb, sitemstr)
13668 13669
13670 -def fl_delete_menu_item(pObject, numb):
13671 """ fl_delete_menu_item(pObject, numb) 13672 """ 13673 13674 _fl_delete_menu_item = cfuncproto( 13675 load_so_libforms(), "fl_delete_menu_item", 13676 None, [cty.POINTER(FL_OBJECT), cty.c_int], 13677 """void fl_delete_menu_item(FL_OBJECT * ob, int numb) DEPRECATED 13678 """) 13679 inumb = convert_to_int(numb) 13680 keep_elem_refs(pObject, numb, inumb) 13681 _fl_delete_menu_item(pObject, inumb)
13682 13683 13684 #already defined in xfdata 13685 FL_PUP_CB = cty.CFUNCTYPE(cty.c_int, cty.c_int) 13686
13687 -def fl_set_menu_item_callback(pObject, numb, py_PupCb):
13688 """ fl_set_menu_item_callback(pObject, numb, py_PupCb) -> callback 13689 """ 13690 13691 _fl_set_menu_item_callback = cfuncproto( 13692 load_so_libforms(), "fl_set_menu_item_callback", 13693 FL_PUP_CB, [cty.POINTER(FL_OBJECT), cty.c_int, FL_PUP_CB], 13694 """FL_PUP_CB fl_set_menu_item_callback(FL_OBJECT * ob, int numb, 13695 FL_PUP_CB cb) 13696 """) 13697 inumb = convert_to_int(numb) 13698 c_PupCb = FL_PUP_CB(py_PupCb) 13699 keep_cfunc_refs(c_PupCb, py_PupCb) 13700 keep_elem_refs(pObject, numb, inumb) 13701 retval = _fl_set_menu_item_callback(pObject, inumb, c_PupCb) 13702 return retval
13703 13704
13705 -def fl_set_menu_item_shortcut(pObject, itemnum, textsc):
13706 """ 13707 fl_set_menu_item_shortcut(pObject, itemnum, textsc) 13708 13709 Sets the shortcut of a menu item. 13710 13711 @param pObject : pointer to menu object 13712 @param itemnum : item number to be operated on 13713 @param textsc : text of shortcut to be set 13714 """ 13715 13716 _fl_set_menu_item_shortcut = cfuncproto( 13717 load_so_libforms(), "fl_set_menu_item_shortcut", 13718 None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 13719 """void fl_set_menu_item_shortcut(FL_OBJECT * ob, int numb, 13720 const char * str) DEPRECATED 13721 """) 13722 iitemnum = convert_to_int(itemnum) 13723 stextsc = convert_to_string(textsc) 13724 keep_elem_refs(pObject, itemnum, stextsc, iitemnum, stextsc) 13725 _fl_set_menu_item_shortcut(pObject, iitemnum, stextsc)
13726 13727
13728 -def fl_set_menu_item_mode(pObject, itemnum, mode):
13729 """ 13730 fl_set_menu_item_mode(pObject, itemnum, mode) 13731 13732 Sets the mode of a menu item. 13733 13734 @param pObject : pointer to menu object 13735 @param itemnum : id of an item to be operated on 13736 @param mode : mode to be set 13737 """ 13738 13739 _fl_set_menu_item_mode = cfuncproto( 13740 load_so_libforms(), "fl_set_menu_item_mode", 13741 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_uint], 13742 """void fl_set_menu_item_mode(FL_OBJECT * ob, int numb, 13743 unsigned int mode) DEPRECATED 13744 """) 13745 iitemnum = convert_to_int(itemnum) 13746 uimode = convert_to_uint(mode) 13747 keep_elem_refs(pObject, itemnum, mode, iitemnum, uimode) 13748 _fl_set_menu_item_mode(pObject, iitemnum, uimode)
13749 13750
13751 -def fl_show_menu_symbol(pObject, showflag):
13752 """ 13753 fl_show_menu_symbol(pObject, showflag) 13754 13755 Makes the menu symbol visible or not. 13756 13757 @param pObject : pointer to menu object 13758 @param showflag : flag to show menu or not (1|0) 13759 """ 13760 13761 _fl_show_menu_symbol = cfuncproto( 13762 load_so_libforms(), "fl_show_menu_symbol", 13763 None, [cty.POINTER(FL_OBJECT), cty.c_int], 13764 """void fl_show_menu_symbol(FL_OBJECT * ob, int show) DEPRECATED 13765 """) 13766 ishowflag = convert_to_int(showflag) 13767 keep_elem_refs(pObject, showflag, ishowflag) 13768 _fl_show_menu_symbol(pObject, ishowflag)
13769 13770
13771 -def fl_set_menu_popup(pObject, pup):
13772 """ fl_set_menu_popup(pObject, pup) 13773 """ 13774 13775 _fl_set_menu_popup = cfuncproto( 13776 load_so_libforms(), "fl_set_menu_popup", 13777 None, [cty.POINTER(FL_OBJECT), cty.c_int], 13778 """void fl_set_menu_popup(FL_OBJECT * ob, int pup) DEPRECATED 13779 """) 13780 ipup = convert_to_int(pup) 13781 keep_elem_refs(pObject, pup, ipup) 13782 _fl_set_menu_popup(pObject, ipup)
13783 13784
13785 -def fl_get_menu_popup(pObject):
13786 """ fl_get_menu_popup(pObject) -> num. 13787 """ 13788 13789 _fl_get_menu_popup = cfuncproto( 13790 load_so_libforms(), "fl_get_menu_popup", 13791 cty.c_int, [cty.POINTER(FL_OBJECT)], 13792 """int fl_get_menu_popup(FL_OBJECT * ob) DEPRECATED 13793 """) 13794 keep_elem_refs(pObject) 13795 retval = _fl_get_menu_popup(pObject) 13796 return retval
13797 13798
13799 -def fl_get_menu(pObject):
13800 """ fl_get_menu(pObject) -> num. 13801 """ 13802 13803 _fl_get_menu = cfuncproto( 13804 load_so_libforms(), "fl_get_menu", 13805 cty.c_int, [cty.POINTER(FL_OBJECT)], 13806 """int fl_get_menu(FL_OBJECT * ob) DEPRECATED 13807 """) 13808 keep_elem_refs(pObject) 13809 retval = _fl_get_menu(pObject) 13810 return retval
13811 13812
13813 -def fl_get_menu_item_text(pObject, numb):
13814 """ fl_get_menu_item_text(pObject, numb) -> text string 13815 """ 13816 13817 _fl_get_menu_item_text = cfuncproto( 13818 load_so_libforms(), "fl_get_menu_item_text", 13819 STRING, [cty.POINTER(FL_OBJECT), cty.c_int], 13820 """const char * fl_get_menu_item_text(FL_OBJECT * ob, int numb) DEPRECATED 13821 """) 13822 inumb = convert_to_int(numb) 13823 keep_elem_refs(pObject, numb, inumb) 13824 retval = _fl_get_menu_item_text(pObject, inumb) 13825 return retval
13826 13827
13828 -def fl_get_menu_maxitems(pObject):
13829 """ fl_get_menu_maxitems(pObject) -> items num. 13830 """ 13831 13832 _fl_get_menu_maxitems = cfuncproto( 13833 load_so_libforms(), "fl_get_menu_maxitems", 13834 cty.c_int, [cty.POINTER(FL_OBJECT)], 13835 """int fl_get_menu_maxitems(FL_OBJECT * ob) DEPRECATED 13836 """) 13837 keep_elem_refs(pObject) 13838 retval = _fl_get_menu_maxitems(pObject) 13839 return retval
13840 13841
13842 -def fl_get_menu_item_mode(pObject, numb):
13843 """ fl_get_menu_item_mode(pObject, numb) -> mode num. 13844 """ 13845 13846 _fl_get_menu_item_mode = cfuncproto( 13847 load_so_libforms(), "fl_get_menu_item_mode", 13848 cty.c_uint, [cty.POINTER(FL_OBJECT), cty.c_int], 13849 """unsigned int fl_get_menu_item_mode(FL_OBJECT * ob, int numb) DEPRECATED 13850 """) 13851 inumb = convert_to_int(numb) 13852 keep_elem_refs(pObject, numb, inumb) 13853 retval = _fl_get_menu_item_mode(pObject, inumb) 13854 return retval
13855 13856
13857 -def fl_get_menu_text(pObject):
13858 """ fl_get_menu_text(pObject) -> text string 13859 """ 13860 13861 _fl_get_menu_text = cfuncproto( 13862 load_so_libforms(), "fl_get_menu_text", 13863 STRING, [cty.POINTER(FL_OBJECT)], 13864 """const char * fl_get_menu_text(FL_OBJECT * ob) DEPRECATED 13865 """) 13866 keep_elem_refs(pObject) 13867 retval = _fl_get_menu_text(pObject) 13868 return retval
13869 13870
13871 -def fl_set_menu_entries(pObject, pPopupEntry):
13872 """ fl_set_menu_entries(pObject, pPopupEntry) -> num. 13873 """ 13874 13875 _fl_set_menu_entries = cfuncproto( 13876 load_so_libforms(), "fl_set_menu_entries", 13877 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_PUP_ENTRY)], 13878 """int fl_set_menu_entries(FL_OBJECT * ob, FL_PUP_ENTRY * ent) DEPRECATED 13879 """) 13880 keep_elem_refs(pObject, pPopupEntry) 13881 retval = _fl_set_menu_entries(pObject, pPopupEntry) 13882 return retval
13883 13884
13885 -def fl_set_menu_notitle(pObject, off):
13886 """ fl_set_menu_notitle(pObject, off) -> num. 13887 """ 13888 13889 _fl_set_menu_notitle = cfuncproto( 13890 load_so_libforms(), "fl_set_menu_notitle", 13891 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 13892 """int fl_set_menu_notitle(FL_OBJECT * ob, int off) DEPRECATED? 13893 """) 13894 ioff = convert_to_int(off) 13895 keep_elem_refs(pObject, off, ioff) 13896 retval = _fl_set_menu_notitle(pObject, ioff) 13897 return retval
13898 13899
13900 -def fl_set_menu_item_id(pObject, item, idnum):
13901 """ fl_set_menu_item_id(pObject, item, idnum) -> num. 13902 """ 13903 13904 _fl_set_menu_item_id = cfuncproto( 13905 load_so_libforms(), "fl_set_menu_item_id", 13906 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 13907 """int fl_set_menu_item_id(FL_OBJECT * ob, int item, int id) 13908 """) 13909 iitem = convert_to_int(item) 13910 iidnum = convert_to_int(idnum) 13911 keep_elem_refs(pObject, item, idnum, iitem, iidnum) 13912 retval = _fl_set_menu_item_id(pObject, iitem, iidnum) 13913 return retval
13914 13915 13916 13917 # Nmenu object types 13918
13919 -def fl_create_nmenu(nmenutype, x, y, w, h, label):
13920 """ 13921 fl_create_nmenu(nmenutype, x, y, w, h, label) -> pObject 13922 13923 Creates a nmenu object. 13924 13925 @param nmenutype : type of nmenu 13926 @param x : horizontal position of nmenu (upper-left corner) 13927 @param y : vertical position of nmenu (upper-left corner) 13928 @param w : width of nmenu object in pixel 13929 @param h : height of nmenu object in pixel 13930 @param label : text label of nmenu object 13931 """ 13932 13933 _fl_create_nmenu = cfuncproto( 13934 load_so_libforms(), "fl_create_nmenu", 13935 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 13936 FL_Coord, STRING], 13937 """FL_OBJECT * fl_create_nmenu(int p1, FL_Coord p2, FL_Coord p3, 13938 FL_Coord p4, FL_Coord p5, const char * p6) 13939 """) 13940 check_admitted_listvalues(nmenutype, NMENUTYPE_list) 13941 inmenutype = convert_to_int(nmenutype) 13942 ix = convert_to_FL_Coord(x) 13943 iy = convert_to_FL_Coord(y) 13944 iw = convert_to_FL_Coord(w) 13945 ih = convert_to_FL_Coord(h) 13946 slabel = convert_to_string(label) 13947 keep_elem_refs(nmenutype, x, y, w, h, label, inmenutype, ix, iy, 13948 iw, ih, slabel) 13949 retval = _fl_create_nmenu(inmenutype, ix, iy, iw, ih, slabel) 13950 return retval
13951 13952
13953 -def fl_add_nmenu(nmenutype, x, y, w, h, label):
13954 """ 13955 fl_add_nmenu(nmenutype, x, y, w, h, label) -> pObject 13956 13957 Adds a nmenu object. 13958 13959 @param nmenutype : type of nmenu object 13960 @param x : horizontal position of nmenu (upper-left corner) 13961 @param y : vertical position of nmenu (upper-left corner) 13962 @param w : width of nmenu object in pixel 13963 @param h : height of nmenu object in pixel 13964 @param label : text label of nmenu object 13965 """ 13966 13967 _fl_add_nmenu = cfuncproto( 13968 load_so_libforms(), "fl_add_nmenu", 13969 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 13970 FL_Coord, STRING], 13971 """FL_OBJECT * fl_add_nmenu(int p1, FL_Coord p2, FL_Coord p3, 13972 FL_Coord p4, FL_Coord p5, const char * p6) 13973 """) 13974 check_admitted_listvalues(nmenutype, NMENUTYPE_list) 13975 inmenutype = convert_to_int(nmenutype) 13976 ix = convert_to_FL_Coord(x) 13977 iy = convert_to_FL_Coord(y) 13978 iw = convert_to_FL_Coord(w) 13979 ih = convert_to_FL_Coord(h) 13980 slabel = convert_to_string(label) 13981 keep_elem_refs(nmenutype, x, y, w, h, label, inmenutype, ix, iy, 13982 iw, ih, slabel) 13983 retval = _fl_add_nmenu(inmenutype, ix, iy, iw, ih, slabel) 13984 return retval
13985 13986
13987 -def fl_clear_nmenu(pObject):
13988 """ fl_clear_nmenu(pObject) -> num. 13989 """ 13990 13991 _fl_clear_nmenu = cfuncproto( 13992 load_so_libforms(), "fl_clear_nmenu", 13993 cty.c_int, [cty.POINTER(FL_OBJECT)], 13994 """int fl_clear_nmenu(FL_OBJECT * p1) 13995 """) 13996 keep_elem_refs(pObject) 13997 retval = _fl_clear_nmenu(pObject) 13998 return retval
13999 14000
14001 -def fl_add_nmenu_items(pObject, itemstr):
14002 """ fl_add_nmenu_items(pObject, itemstr) -> pPopupEntry 14003 """ 14004 14005 _fl_add_nmenu_items = cfuncproto( 14006 load_so_libforms(), "fl_add_nmenu_items", 14007 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), STRING], 14008 """FL_POPUP_ENTRY * fl_add_nmenu_items(FL_OBJECT * p1, 14009 const char * p2) 14010 """) 14011 sitemstr = convert_to_string(itemstr) 14012 keep_elem_refs(pObject, itemstr, sitemstr) 14013 retval = _fl_add_nmenu_items(pObject, sitemstr) 14014 return retval
14015 14016
14017 -def fl_insert_nmenu_items(pObject, pPopupEntry, itemstr):
14018 """ fl_insert_nmenu_items(pObject, pPopupEntry, itemstr) -> pPopupEntry 14019 """ 14020 14021 _fl_insert_nmenu_items = cfuncproto( 14022 load_so_libforms(), "fl_insert_nmenu_items", 14023 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), 14024 cty.POINTER(FL_POPUP_ENTRY), STRING], 14025 """FL_POPUP_ENTRY * fl_insert_nmenu_items(FL_OBJECT * p1, 14026 FL_POPUP_ENTRY * p2, const char * p3) 14027 """) 14028 sitemstr = convert_to_string(itemstr) 14029 keep_elem_refs(pObject, pPopupEntry, itemstr, sitemstr) 14030 retval = _fl_insert_nmenu_items(pObject, pPopupEntry, sitemstr) 14031 return retval
14032 14033
14034 -def fl_replace_nmenu_item(pObject, pPopupEntry, itemstr):
14035 """ fl_replace_nmenu_item(pObject, pPopupEntry, itemstr) -> pPopupEntry 14036 """ 14037 14038 _fl_replace_nmenu_item = cfuncproto( 14039 load_so_libforms(), "fl_replace_nmenu_item", 14040 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), 14041 cty.POINTER(FL_POPUP_ENTRY), STRING], 14042 """FL_POPUP_ENTRY * fl_replace_nmenu_item(FL_OBJECT * p1, 14043 FL_POPUP_ENTRY * p2, const char * p3) 14044 """) 14045 sitemstr = convert_to_string(itemstr) 14046 keep_elem_refs(pObject, pPopupEntry, itemstr, sitemstr) 14047 retval = _fl_replace_nmenu_item(pObject, pPopupEntry, sitemstr) 14048 return retval
14049 14050
14051 -def fl_delete_nmenu_item(pObject, pPopupEntry):
14052 """ fl_delete_nmenu_item(pObject, pPopupEntry) -> num. 14053 """ 14054 14055 _fl_delete_nmenu_item = cfuncproto( 14056 load_so_libforms(), "fl_delete_nmenu_item", 14057 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_POPUP_ENTRY)], 14058 """int fl_delete_nmenu_item(FL_OBJECT * p1, FL_POPUP_ENTRY * p2) 14059 """) 14060 keep_elem_refs(pObject, pPopupEntry) 14061 retval = _fl_delete_nmenu_item(pObject, pPopupEntry) 14062 return retval
14063 14064
14065 -def fl_set_nmenu_items(pObject, pPopupItem):
14066 """ fl_set_nmenu_items(pObject, pPopupItem) -> pPopupEntry 14067 """ 14068 14069 _fl_set_nmenu_items = cfuncproto( 14070 load_so_libforms(), "fl_set_nmenu_items", 14071 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), 14072 cty.POINTER(FL_POPUP_ITEM)], 14073 """FL_POPUP_ENTRY * fl_set_nmenu_items(FL_OBJECT * p1, 14074 FL_POPUP_ITEM * p2) 14075 """) 14076 keep_elem_refs(pObject, pPopupItem) 14077 retval = _fl_set_nmenu_items(pObject, pPopupItem) 14078 return retval
14079 14080
14081 -def fl_get_nmenu_popup(pObject):
14082 """ fl_get_nmenu_popup(pObject) -> pPopup 14083 """ 14084 14085 _fl_get_nmenu_popup = cfuncproto( 14086 load_so_libforms(), "fl_get_nmenu_popup", 14087 cty.POINTER(FL_POPUP), [cty.POINTER(FL_OBJECT)], 14088 """FL_POPUP * fl_get_nmenu_popup(FL_OBJECT * p1) 14089 """) 14090 keep_elem_refs(pObject) 14091 retval = _fl_get_nmenu_popup(pObject) 14092 return retval
14093 14094
14095 -def fl_set_nmenu_popup(pObject, pPopup):
14096 """ fl_set_nmenu_popup(pObject, pPopup) -> num. 14097 """ 14098 14099 _fl_set_nmenu_popup = cfuncproto( 14100 load_so_libforms(), "fl_set_nmenu_popup", 14101 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_POPUP)], 14102 """int fl_set_nmenu_popup(FL_OBJECT * p1, FL_POPUP * p2) 14103 """) 14104 keep_elem_refs(pObject, pPopup) 14105 retval = _fl_set_nmenu_popup(pObject, pPopup) 14106 return retval
14107 14108
14109 -def fl_get_nmenu_item(pObject):
14110 """ fl_get_nmenu_item(pObject) -> pPopupReturn 14111 """ 14112 14113 _fl_get_nmenu_item = cfuncproto( 14114 load_so_libforms(), "fl_get_nmenu_item", 14115 cty.POINTER(FL_POPUP_RETURN), [cty.POINTER(FL_OBJECT)], 14116 """FL_POPUP_RETURN * fl_get_nmenu_item(FL_OBJECT * p1) 14117 """) 14118 keep_elem_refs(pObject) 14119 retval = _fl_get_nmenu_item(pObject) 14120 return retval
14121 14122
14123 -def fl_get_nmenu_item_by_value(pObject, value):
14124 """ fl_get_nmenu_item_by_value(pObject, value) -> pPopupEntry 14125 """ 14126 14127 _fl_get_nmenu_item_by_value = cfuncproto( 14128 load_so_libforms(), "fl_get_nmenu_item_by_value", 14129 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), cty.c_long], 14130 """FL_POPUP_ENTRY * fl_get_nmenu_item_by_value(FL_OBJECT * p1, 14131 long int p2) 14132 """) 14133 lvalue = convert_to_long(value) 14134 keep_elem_refs(pObject, value, lvalue) 14135 retval = _fl_get_nmenu_item_by_value(pObject, lvalue) 14136 return retval
14137 14138
14139 -def fl_get_nmenu_item_by_label(pObject, label):
14140 """ fl_get_nmenu_item_by_label(pObject, label) -> pPopupEntry 14141 """ 14142 14143 _fl_get_nmenu_item_by_label = cfuncproto( 14144 load_so_libforms(), "fl_get_nmenu_item_by_label", 14145 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), STRING], 14146 """FL_POPUP_ENTRY * fl_get_nmenu_item_by_label(FL_OBJECT * p1, 14147 const char * p2) 14148 """) 14149 slabel = convert_to_string(label) 14150 keep_elem_refs(pObject, label, slabel) 14151 retval = _fl_get_nmenu_item_by_label(pObject, slabel) 14152 return retval
14153 14154
14155 -def fl_get_nmenu_item_by_text(pObject, text):
14156 """ fl_get_nmenu_item_by_text(pObject, text) -> pPopupEntry 14157 """ 14158 14159 _fl_get_nmenu_item_by_text = cfuncproto( 14160 load_so_libforms(), "fl_get_nmenu_item_by_text", 14161 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), STRING], 14162 """FL_POPUP_ENTRY * fl_get_nmenu_item_by_text(FL_OBJECT * p1, 14163 const char * p2) 14164 """) 14165 stext = convert_to_string(text) 14166 keep_elem_refs(pObject, text, stext) 14167 retval = _fl_get_nmenu_item_by_text(pObject, stext) 14168 return retval
14169 14170
14171 -def fl_set_nmenu_policy(pObject, num):
14172 """ fl_set_nmenu_policy(pObject, num) -> num. 14173 """ 14174 14175 _fl_set_nmenu_policy = cfuncproto( 14176 load_so_libforms(), "fl_set_nmenu_policy", 14177 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 14178 """int fl_set_nmenu_policy(FL_OBJECT * p1, int p2) 14179 """) 14180 inum = convert_to_int(num) 14181 keep_elem_refs(pObject, num, inum) 14182 retval = _fl_set_nmenu_policy(pObject, inum) 14183 return retval
14184 14185
14186 -def fl_set_nmenu_hl_text_color(pObject, colr):
14187 """ fl_set_nmenu_hl_text_color(pObject, colr) -> color 14188 """ 14189 14190 _fl_set_nmenu_hl_text_color = cfuncproto( 14191 load_so_libforms(), "fl_set_nmenu_hl_text_color", 14192 FL_COLOR, [cty.POINTER(FL_OBJECT), FL_COLOR], 14193 """FL_COLOR fl_set_nmenu_hl_text_color(FL_OBJECT * p1, 14194 FL_COLOR p2) 14195 """) 14196 ulcolr = convert_to_FL_COLOR(colr) 14197 keep_elem_refs(pObject, colr, ulcolr) 14198 retval = _fl_set_nmenu_hl_text_color(pObject, ulcolr) 14199 return retval
14200 14201 14202 14203 ######################### 14204 # forms.h (positioner.h) 14205 ######################### 14206 14207 # Routines 14208
14209 -def fl_create_positioner(postype, x, y, w, h, label):
14210 """ fl_create_positioner(postype, x, y, w, h, label) -> pObject 14211 """ 14212 14213 _fl_create_positioner = cfuncproto( 14214 load_so_libforms(), "fl_create_positioner", 14215 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 14216 FL_Coord, STRING], 14217 """FL_OBJECT * fl_create_positioner(int type, FL_Coord x, 14218 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 14219 """) 14220 check_admitted_listvalues(postype, POSITIONERTYPE_list) 14221 ipostype = convert_to_int(postype) 14222 ix = convert_to_FL_Coord(x) 14223 iy = convert_to_FL_Coord(y) 14224 iw = convert_to_FL_Coord(w) 14225 ih = convert_to_FL_Coord(h) 14226 slabel = convert_to_string(label) 14227 keep_elem_refs(postype, x, y, w, h, label, ipostype, ix, iy, 14228 iw, ih, slabel) 14229 retval = _fl_create_positioner(ipostype, ix, iy, iw, ih, slabel) 14230 return retval
14231 14232
14233 -def fl_add_positioner(postype, x, y, w, h, label):
14234 """ fl_add_positioner(postype, x, y, w, h, label) -> pObject 14235 """ 14236 14237 _fl_add_positioner = cfuncproto( 14238 load_so_libforms(), "fl_add_positioner", 14239 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 14240 FL_Coord, STRING], 14241 """FL_OBJECT * fl_add_positioner(int type, FL_Coord x, FL_Coord y, 14242 FL_Coord w, FL_Coord h, const char * label) 14243 """) 14244 check_admitted_listvalues(postype, POSITIONERTYPE_list) 14245 ipostype = convert_to_int(postype) 14246 ix = convert_to_FL_Coord(x) 14247 iy = convert_to_FL_Coord(y) 14248 iw = convert_to_FL_Coord(w) 14249 ih = convert_to_FL_Coord(h) 14250 slabel = convert_to_string(label) 14251 keep_elem_refs(postype, x, y, w, h, label, ipostype, ix, iy, 14252 iw, ih, slabel) 14253 retval = _fl_add_positioner(ipostype, ix, iy, iw, ih, slabel) 14254 return retval
14255 14256
14257 -def fl_set_positioner_xvalue(pObject, val):
14258 """ fl_set_positioner_xvalue(pObject, val) 14259 """ 14260 14261 _fl_set_positioner_xvalue = cfuncproto( 14262 load_so_libforms(), "fl_set_positioner_xvalue", 14263 None, [cty.POINTER(FL_OBJECT), cty.c_double], 14264 """void fl_set_positioner_xvalue(FL_OBJECT * ob, double val) 14265 """) 14266 fval = convert_to_double(val) 14267 keep_elem_refs(pObject, val, fval) 14268 _fl_set_positioner_xvalue(pObject, fval)
14269 14270
14271 -def fl_get_positioner_xvalue(pObject):
14272 """ fl_get_positioner_xvalue(pObject) -> floatnum 14273 """ 14274 14275 _fl_get_positioner_xvalue = cfuncproto( 14276 load_so_libforms(), "fl_get_positioner_xvalue", 14277 cty.c_double, [cty.POINTER(FL_OBJECT)], 14278 """double fl_get_positioner_xvalue(FL_OBJECT * ob) 14279 """) 14280 keep_elem_refs(pObject) 14281 retval = _fl_get_positioner_xvalue(pObject) 14282 return retval
14283 14284
14285 -def fl_set_positioner_xbounds(pObject, minbound, maxbound):
14286 """ fl_set_positioner_xbounds(pObject, minbound, maxbound) 14287 """ 14288 14289 _fl_set_positioner_xbounds = cfuncproto( 14290 load_so_libforms(), "fl_set_positioner_xbounds", 14291 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 14292 """void fl_set_positioner_xbounds(FL_OBJECT * ob, double min, 14293 double max) 14294 """) 14295 fminbound = convert_to_double(minbound) 14296 fmaxbound = convert_to_double(maxbound) 14297 keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 14298 _fl_set_positioner_xbounds(pObject, fminbound, fmaxbound)
14299 14300 14301 #def fl_get_positioner_xbounds(pObject, minbound, maxbound) *API change*
14302 -def fl_get_positioner_xbounds(pObject):
14303 """ fl_get_positioner_xbounds(pObject) -> minbound, maxbound 14304 """ 14305 14306 _fl_get_positioner_xbounds = cfuncproto( 14307 load_so_libforms(), "fl_get_positioner_xbounds", 14308 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 14309 cty.POINTER(cty.c_double)], 14310 """void fl_get_positioner_xbounds(FL_OBJECT * ob, double * min, 14311 double * max) 14312 """) 14313 minbound, pminbound = make_double_and_pointer() 14314 maxbound, pmaxbound = make_double_and_pointer() 14315 keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 14316 _fl_get_positioner_xbounds(pObject, pminbound, pmaxbound) 14317 return minbound, maxbound
14318 14319
14320 -def fl_set_positioner_yvalue(pObject, val):
14321 """ fl_set_positioner_yvalue(pObject, val) 14322 """ 14323 14324 _fl_set_positioner_yvalue = cfuncproto( 14325 load_so_libforms(), "fl_set_positioner_yvalue", 14326 None, [cty.POINTER(FL_OBJECT), cty.c_double], 14327 """void fl_set_positioner_yvalue(FL_OBJECT * ob, double val) 14328 """) 14329 fval = convert_to_double(val) 14330 keep_elem_refs(pObject, val, fval) 14331 _fl_set_positioner_yvalue(pObject, fval)
14332 14333
14334 -def fl_get_positioner_yvalue(pObject):
14335 """ fl_get_positioner_yvalue(pObject) -> floatnum 14336 """ 14337 14338 _fl_get_positioner_yvalue = cfuncproto( 14339 load_so_libforms(), "fl_get_positioner_yvalue", 14340 cty.c_double, [cty.POINTER(FL_OBJECT)], 14341 """double fl_get_positioner_yvalue(FL_OBJECT * ob) 14342 """) 14343 keep_elem_refs(pObject) 14344 retval = _fl_get_positioner_yvalue(pObject) 14345 return retval
14346 14347
14348 -def fl_set_positioner_ybounds(pObject, minbound, maxbound):
14349 """ fl_set_positioner_ybounds(pObject, minbound, maxbound) 14350 """ 14351 14352 _fl_set_positioner_ybounds = cfuncproto( 14353 load_so_libforms(), "fl_set_positioner_ybounds", 14354 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 14355 """void fl_set_positioner_ybounds(FL_OBJECT * ob, double min, 14356 double max) 14357 """) 14358 fminbound = convert_to_double(minbound) 14359 fmaxbound = convert_to_double(maxbound) 14360 keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 14361 _fl_set_positioner_ybounds(pObject, fminbound, fmaxbound)
14362 14363 14364 #def fl_get_positioner_ybounds(pObject, minbound, maxbound) *API change*
14365 -def fl_get_positioner_ybounds(pObject):
14366 """ fl_get_positioner_ybounds(pObject) -> minbound, maxbound 14367 """ 14368 14369 _fl_get_positioner_ybounds = cfuncproto( 14370 load_so_libforms(), "fl_get_positioner_ybounds", 14371 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 14372 cty.POINTER(cty.c_double)], 14373 """void fl_get_positioner_ybounds(FL_OBJECT * ob, double * min, 14374 double * max) 14375 """) 14376 minbound, pminbound = make_double_and_pointer() 14377 maxbound, pmaxbound = make_double_and_pointer() 14378 keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 14379 _fl_get_positioner_ybounds(pObject, pminbound, pmaxbound) 14380 return minbound, maxbound
14381 14382
14383 -def fl_set_positioner_xstep(pObject, value):
14384 """ fl_set_positioner_xstep(pObject, value) 14385 """ 14386 14387 _fl_set_positioner_xstep = cfuncproto( 14388 load_so_libforms(), "fl_set_positioner_xstep", 14389 None, [cty.POINTER(FL_OBJECT), cty.c_double], 14390 """void fl_set_positioner_xstep(FL_OBJECT * ob, double value) 14391 """) 14392 fvalue = convert_to_double(value) 14393 keep_elem_refs(pObject, value, fvalue) 14394 _fl_set_positioner_xstep(pObject, fvalue)
14395 14396
14397 -def fl_set_positioner_ystep(pObject, value):
14398 """ fl_set_positioner_ystep(pObject, value) 14399 """ 14400 14401 _fl_set_positioner_ystep = cfuncproto( 14402 load_so_libforms(), "fl_set_positioner_ystep", 14403 None, [cty.POINTER(FL_OBJECT), cty.c_double], 14404 """void fl_set_positioner_ystep(FL_OBJECT * ob, double value) 14405 """) 14406 fvalue = convert_to_double(value) 14407 keep_elem_refs(pObject, value, fvalue) 14408 _fl_set_positioner_ystep(pObject, fvalue)
14409 14410
14411 -def fl_set_positioner_return(pObject, value):
14412 """ fl_set_positioner_return(pObject, value) 14413 """ 14414 14415 _fl_set_positioner_return = cfuncproto( 14416 load_so_libforms(), "fl_set_positioner_return", 14417 None, [cty.POINTER(FL_OBJECT), cty.c_int], 14418 """void fl_set_positioner_return(FL_OBJECT * ob, int value) 14419 """) 14420 ivalue = convert_to_int(value) 14421 keep_elem_refs(pObject, value, ivalue) 14422 _fl_set_positioner_return(pObject, ivalue)
14423 14424
14425 -def fl_create_scrollbar(scrolltype, x, y, w, h, label):
14426 """ fl_create_scrollbar(scrolltype, x, y, w, h, label) -> pObject 14427 """ 14428 14429 _fl_create_scrollbar = cfuncproto( 14430 load_so_libforms(), "fl_create_scrollbar", 14431 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 14432 FL_Coord, STRING], 14433 """FL_OBJECT * fl_create_scrollbar(int type, FL_Coord x, 14434 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 14435 """) 14436 check_admitted_listvalues(scrolltype, SCROLLTYPE_list) 14437 iscrolltype = convert_to_int(scrolltype) 14438 ix = convert_to_FL_Coord(x) 14439 iy = convert_to_FL_Coord(y) 14440 iw = convert_to_FL_Coord(w) 14441 ih = convert_to_FL_Coord(h) 14442 slabel = convert_to_string(label) 14443 keep_elem_refs(scrolltype, x, y, w, h, label, iscrolltype, ix, iy, 14444 iw, ih, slabel) 14445 retval = _fl_create_scrollbar(iscrolltype, ix, iy, iw, ih, slabel) 14446 return retval
14447 14448
14449 -def fl_add_scrollbar(scrolltype, x, y, w, h, label):
14450 """ 14451 fl_add_scrollbar(scrolltype, x, y, w, h, label) -> pObject 14452 14453 Adds a scrollbar to a form. 14454 14455 @param scrolltype : type of scrollbar 14456 @param x : horizontal position (upper-left corner) 14457 @param y : vertical position (upper-left corner) 14458 @param w : width of the scrollbar 14459 @param h : height of the scrollbar 14460 @param label : label text of the scrollbar 14461 """ 14462 14463 _fl_add_scrollbar = cfuncproto( 14464 load_so_libforms(), "fl_add_scrollbar", 14465 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 14466 FL_Coord, STRING], 14467 """FL_OBJECT * fl_add_scrollbar(int type, FL_Coord x, FL_Coord y, 14468 FL_Coord w, FL_Coord h, const char * label) 14469 """) 14470 check_admitted_listvalues(scrolltype, SCROLLTYPE_list) 14471 iscrolltype = convert_to_int(scrolltype) 14472 ix = convert_to_FL_Coord(x) 14473 iy = convert_to_FL_Coord(y) 14474 iw = convert_to_FL_Coord(w) 14475 ih = convert_to_FL_Coord(h) 14476 slabel = convert_to_string(label) 14477 keep_elem_refs(scrolltype, x, y, w, h, label, iscrolltype, ix, iy, 14478 iw, ih, slabel) 14479 retval = _fl_add_scrollbar(iscrolltype, ix, iy, iw, ih, slabel) 14480 return retval
14481 14482
14483 -def fl_get_scrollbar_value(pObject):
14484 """ 14485 fl_get_scrollbar_value(pObject) -> value[float] 14486 14487 Returns the value of a scrollbar. 14488 14489 @param pObject : pointer to object 14490 """ 14491 14492 _fl_get_scrollbar_value = cfuncproto( 14493 load_so_libforms(), "fl_get_scrollbar_value", 14494 cty.c_double, [cty.POINTER(FL_OBJECT)], 14495 """double fl_get_scrollbar_value(FL_OBJECT * ob) 14496 """) 14497 keep_elem_refs(pObject) 14498 retval = _fl_get_scrollbar_value(pObject) 14499 return retval
14500 14501
14502 -def fl_set_scrollbar_value(pObject, val):
14503 """ 14504 fl_set_scrollbar_value(pObject, val) 14505 14506 Sets the value of a scrollbar. 14507 14508 @param pObject : pointer to object 14509 @param val : value of the scrollbar to be set 14510 """ 14511 14512 _fl_set_scrollbar_value = cfuncproto( 14513 load_so_libforms(), "fl_set_scrollbar_value", 14514 None, [cty.POINTER(FL_OBJECT), cty.c_double], 14515 """void fl_set_scrollbar_value(FL_OBJECT * ob, double val) 14516 """) 14517 fval = convert_to_double(val) 14518 keep_elem_refs(pObject, val, fval) 14519 _fl_set_scrollbar_value(pObject, fval)
14520 14521
14522 -def fl_set_scrollbar_size(pObject, val):
14523 """ fl_set_scrollbar_size(pObject, val) 14524 """ 14525 14526 _fl_set_scrollbar_size = cfuncproto( 14527 load_so_libforms(), "fl_set_scrollbar_size", 14528 None, [cty.POINTER(FL_OBJECT), cty.c_double], 14529 """void fl_set_scrollbar_size(FL_OBJECT * ob, double val) 14530 """) 14531 fval = convert_to_double(val) 14532 keep_elem_refs(pObject, val, fval) 14533 _fl_set_scrollbar_size(pObject, fval)
14534 14535
14536 -def fl_set_scrollbar_increment(pObject, leftbtnval, midlbtnval):
14537 """ 14538 fl_set_scrollbar_increment(pObject, leftbtnval, midlbtnval) 14539 14540 Sets the size of the steps of a scrollbar jump. 14541 14542 @param pObject : pointer to object 14543 @param leftbtnval : value to increment if the left mouse button is 14544 pressed 14545 @param midlbtnval : value to increment if the middle mouse button is 14546 pressed 14547 """ 14548 14549 _fl_set_scrollbar_increment = cfuncproto( 14550 load_so_libforms(), "fl_set_scrollbar_increment", 14551 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 14552 """void fl_set_scrollbar_increment(FL_OBJECT * ob, double l, 14553 double r) 14554 """) 14555 fleftbtnval = convert_to_double(leftbtnval) 14556 fmidlbtnval = convert_to_double(midlbtnval) 14557 keep_elem_refs(pObject, leftbtnval, midlbtnval, fleftbtnval, \ 14558 fmidlbtnval) 14559 _fl_set_scrollbar_increment(pObject, fleftbtnval, fmidlbtnval)
14560 14561 14562 #def fl_get_scrollbar_increment(pObject, leftbtnval, valmidlbtnval) *API change*
14563 -def fl_get_scrollbar_increment(pObject):
14564 """ 14565 fl_get_scrollbar_increment(pObject) -> leftbtnval[double], midlbtnval[double] 14566 14567 Returns the increment of size of a scrollbar for left and middle mouse 14568 buttons. 14569 14570 @param pObject : pointer to object 14571 """ 14572 14573 _fl_get_scrollbar_increment = cfuncproto( 14574 load_so_libforms(), "fl_get_scrollbar_increment", 14575 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 14576 cty.POINTER(cty.c_double)], 14577 """void fl_get_scrollbar_increment(FL_OBJECT * ob, double * a, 14578 double * b) 14579 """) 14580 leftbtnval, pleftbtnval = make_double_and_pointer() 14581 midlbtnval, pmidlbtnval = make_double_and_pointer() 14582 keep_elem_refs(pObject, leftbtnval, midlbtnval, pleftbtnval, pmidlbtnval) 14583 _fl_get_scrollbar_increment(pObject, pleftbtnval, pmidlbtnval) 14584 return leftbtnval, midlbtnval
14585 14586
14587 -def fl_set_scrollbar_bounds(pObject, minbound, maxbound):
14588 """ 14589 fl_set_scrollbar_bounds(pObject, minbound, maxbound) 14590 14591 Sets the bounds/limits of a scrollbar. 14592 14593 @param pObject : pointer to object 14594 @param minbound : minimum bound of scrollbar 14595 @param maxbound : maximum bound of scrollbar 14596 """ 14597 14598 _fl_set_scrollbar_bounds = cfuncproto( 14599 load_so_libforms(), "fl_set_scrollbar_bounds", 14600 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 14601 """void fl_set_scrollbar_bounds(FL_OBJECT * ob, double b1, double b2) 14602 """) 14603 fminbound = convert_to_double(minbound) 14604 fmaxbound = convert_to_double(maxbound) 14605 keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 14606 _fl_set_scrollbar_bounds(pObject, fminbound, fmaxbound)
14607 14608 14609 #def fl_get_scrollbar_bounds(pObject, b1, b2) *API change*
14610 -def fl_get_scrollbar_bounds(pObject):
14611 """ 14612 fl_get_scrollbar_bounds(pObject) -> minbound, maxbound 14613 14614 Returns the bounds/limits of a scrollbar. 14615 14616 @param pObject : pointer to scrollbar object 14617 """ 14618 14619 _fl_get_scrollbar_bounds = cfuncproto( 14620 load_so_libforms(), "fl_get_scrollbar_bounds", 14621 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 14622 cty.POINTER(cty.c_double)], 14623 """void fl_get_scrollbar_bounds(FL_OBJECT * ob, double * b1, 14624 double * b2) 14625 """) 14626 minbound, pminbound = make_double_and_pointer() 14627 maxbound, pmaxbound = make_double_and_pointer() 14628 keep_elem_refs(pObject, minbound, pminbound, maxbound, pmaxbound) 14629 _fl_get_scrollbar_bounds(pObject, pminbound, pmaxbound) 14630 return minbound, maxbound
14631 14632
14633 -def fl_set_scrollbar_return(pObject, returnnum):
14634 """ 14635 fl_set_scrollbar_return(pObject, returnnum) 14636 14637 Sets the type of return of a scrollbar. 14638 14639 @param pObject : pointer to scrollbar object 14640 @param returnnum : value of return type 14641 """ 14642 14643 _fl_set_scrollbar_return = cfuncproto( 14644 load_so_libforms(), "fl_set_scrollbar_return", 14645 None, [cty.POINTER(FL_OBJECT), cty.c_int], 14646 """void fl_set_scrollbar_return(FL_OBJECT * ob, int ret) 14647 """) 14648 check_admitted_listvalues(returnnum, RETURN_list) 14649 ireturnnum = convert_to_int(returnnum) 14650 keep_elem_refs(pObject, returnnum, ireturnnum) 14651 _fl_set_scrollbar_return(pObject, ireturnnum)
14652 14653
14654 -def fl_set_scrollbar_step(pObject, step):
14655 """ fl_set_scrollbar_step(pObject, step) 14656 """ 14657 14658 _fl_set_scrollbar_step = cfuncproto( 14659 load_so_libforms(), "fl_set_scrollbar_step", 14660 None, [cty.POINTER(FL_OBJECT), cty.c_double], 14661 """void fl_set_scrollbar_step(FL_OBJECT * ob, double step) 14662 """) 14663 fstep = convert_to_double(step) 14664 keep_elem_refs(pObject, step, fstep) 14665 _fl_set_scrollbar_step(pObject, fstep)
14666 14667 14668 14669 ##################### 14670 # forms.h (select.h) 14671 ##################### 14672 14673 # Select object types 14674
14675 -def fl_create_select(selecttype, x, y, w, h, label):
14676 """ fl_create_select(selecttype, x, y, w, h, label) -> pObject 14677 """ 14678 14679 _fl_create_select = cfuncproto( 14680 load_so_libforms(), "fl_create_select", 14681 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 14682 FL_Coord, STRING], 14683 """FL_OBJECT * fl_create_select(int p1, FL_Coord p2, FL_Coord p3, 14684 FL_Coord p4, FL_Coord p5, const char * p6) 14685 """) 14686 check_admitted_listvalues(selecttype, SELECTTYPE_list) 14687 iselecttype = convert_to_int(selecttype) 14688 ix = convert_to_FL_Coord(x) 14689 iy = convert_to_FL_Coord(y) 14690 iw = convert_to_FL_Coord(w) 14691 ih = convert_to_FL_Coord(h) 14692 slabel = convert_to_string(label) 14693 keep_elem_refs(selecttype, x, y, w, h, label, iselecttype, ix, iy, 14694 iw, ih, slabel) 14695 retval = _fl_create_select(iselecttype, ix, iy, iw, ih, slabel) 14696 return retval
14697 14698
14699 -def fl_add_select(selecttype, x, y, w, h, label):
14700 """ fl_add_select(selecttype, x, y, w, h, label) -> pObject 14701 """ 14702 14703 _fl_add_select = cfuncproto( 14704 load_so_libforms(), "fl_add_select", 14705 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 14706 FL_Coord, STRING], 14707 """FL_OBJECT * fl_add_select(int p1, FL_Coord p2, FL_Coord p3, 14708 FL_Coord p4, FL_Coord p5, const char * p6) 14709 """) 14710 check_admitted_listvalues(selecttype, SELECTTYPE_list) 14711 iselecttype = convert_to_int(selecttype) 14712 ix = convert_to_FL_Coord(x) 14713 iy = convert_to_FL_Coord(y) 14714 iw = convert_to_FL_Coord(w) 14715 ih = convert_to_FL_Coord(h) 14716 slabel = convert_to_string(label) 14717 keep_elem_refs(selecttype, x, y, w, h, label, iselecttype, ix, iy, 14718 iw, ih, slabel) 14719 retval = _fl_add_select(iselecttype, ix, iy, iw, ih, slabel) 14720 return retval
14721 14722
14723 -def fl_clear_select(pObject):
14724 """ fl_clear_select(pObject) 14725 14726 @param pObject : pointer to select object 14727 """ 14728 14729 _fl_clear_select = cfuncproto( 14730 load_so_libforms(), "fl_clear_select", 14731 cty.c_int, [cty.POINTER(FL_OBJECT)], 14732 """int fl_clear_select(FL_OBJECT * p1) 14733 """) 14734 keep_elem_refs(pObject) 14735 _fl_clear_select(pObject)
14736 14737
14738 -def fl_add_select_items(pObject, itemstr):
14739 """ fl_add_select_items(pObject, itemstr) -> pPopupEntry 14740 """ 14741 14742 _fl_add_select_items = cfuncproto( 14743 load_so_libforms(), "fl_add_select_items", 14744 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), STRING], 14745 """FL_POPUP_ENTRY * fl_add_select_items(FL_OBJECT * p1, 14746 const char * p2) 14747 """) 14748 sitemstr = convert_to_string(itemstr) 14749 keep_elem_refs(pObject, itemstr, sitemstr) 14750 retval = _fl_add_select_items(pObject, sitemstr) 14751 return retval
14752 14753
14754 -def fl_insert_select_items(pObject, pPopupEntry, itemstr):
14755 """ fl_insert_select_items(pObject, pPopupEntry, itemstr) -> pPopupEntry 14756 """ 14757 14758 _fl_insert_select_items = cfuncproto( 14759 load_so_libforms(), "fl_insert_select_items", 14760 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), 14761 cty.POINTER(FL_POPUP_ENTRY), STRING], 14762 """FL_POPUP_ENTRY * fl_insert_select_items(FL_OBJECT * p1, 14763 FL_POPUP_ENTRY * p2, const char * p3) 14764 """) 14765 sitemstr = convert_to_string(itemstr) 14766 keep_elem_refs(pObject, pPopupEntry, itemstr, sitemstr) 14767 retval = _fl_insert_select_items(pObject, pPopupEntry, sitemstr) 14768 return retval
14769 14770
14771 -def fl_replace_select_item(pObject, pPopupEntry, itemstr):
14772 """ fl_replace_select_item(pObject, pPopupEntry, itemstr) -> pPopupEntry 14773 """ 14774 14775 _fl_replace_select_item = cfuncproto( 14776 load_so_libforms(), "fl_replace_select_item", 14777 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), 14778 cty.POINTER(FL_POPUP_ENTRY), STRING], 14779 """FL_POPUP_ENTRY * fl_replace_select_item(FL_OBJECT * p1, 14780 FL_POPUP_ENTRY * p2, const char * p3) 14781 """) 14782 sitemstr = convert_to_string(itemstr) 14783 keep_elem_refs(pObject, pPopupEntry, itemstr, sitemstr) 14784 retval = _fl_replace_select_item(pObject, pPopupEntry, sitemstr) 14785 return retval
14786 14787
14788 -def fl_delete_select_item(pObject, pPopupEntry):
14789 """ fl_delete_select_item(pObject, pPopupEntry) -> num. 14790 """ 14791 14792 _fl_delete_select_item = cfuncproto( 14793 load_so_libforms(), "fl_delete_select_item", 14794 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_POPUP_ENTRY)], 14795 """int fl_delete_select_item(FL_OBJECT * p1, FL_POPUP_ENTRY * p2) 14796 """) 14797 keep_elem_refs(pObject, pPopupEntry) 14798 retval = _fl_delete_select_item(pObject, pPopupEntry) 14799 return retval
14800 14801
14802 -def fl_set_select_items(pObject, pPopupItem):
14803 """ 14804 fl_set_select_items(pObject, pPopupItem) -> num. 14805 14806 Repopulates a select object popup. 14807 14808 @param pObject : pointer to select object 14809 @param pPopupItem : pointer to xfc.FL_POPUP_ITEM structure 14810 """ 14811 14812 _fl_set_select_items = cfuncproto( 14813 load_so_libforms(), "fl_set_select_items", 14814 cty.c_long, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_POPUP_ITEM)], 14815 """long int fl_set_select_items(FL_OBJECT * p1, 14816 FL_POPUP_ITEM * p2) 14817 """) 14818 #pPopupItem.callback = FL_POPUP_CB() 14819 keep_elem_refs(pObject, pPopupItem) 14820 retval = _fl_set_select_items(pObject, pPopupItem) 14821 return retval
14822 14823
14824 -def fl_get_select_popup(pObject):
14825 """ fl_get_select_popup(pObject) -> pPopup 14826 """ 14827 14828 _fl_get_select_popup = cfuncproto( 14829 load_so_libforms(), "fl_get_select_popup", 14830 cty.POINTER(FL_POPUP), [cty.POINTER(FL_OBJECT)], 14831 """FL_POPUP * fl_get_select_popup(FL_OBJECT * p1) 14832 """) 14833 keep_elem_refs(pObject) 14834 retval = _fl_get_select_popup(pObject) 14835 return retval
14836 14837
14838 -def fl_set_select_popup(pObject, pPopup):
14839 """ fl_set_select_popup(pObject, pPopup) -> num. 14840 """ 14841 14842 _fl_set_select_popup = cfuncproto( 14843 load_so_libforms(), "fl_set_select_popup", 14844 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_POPUP)], 14845 """int fl_set_select_popup(FL_OBJECT * p1, FL_POPUP * p2) 14846 """) 14847 keep_elem_refs(pObject, pPopup) 14848 retval = _fl_set_select_popup(pObject, pPopup) 14849 return retval
14850 14851
14852 -def fl_get_select_item(pObject):
14853 """ fl_get_select_item(pObject) -> pPopupReturn 14854 """ 14855 14856 _fl_get_select_item = cfuncproto( 14857 load_so_libforms(), "fl_get_select_item", 14858 cty.POINTER(FL_POPUP_RETURN), [cty.POINTER(FL_OBJECT)], 14859 """FL_POPUP_RETURN * fl_get_select_item(FL_OBJECT * p1) 14860 """) 14861 keep_elem_refs(pObject) 14862 retval = _fl_get_select_item(pObject) 14863 return retval
14864 14865
14866 -def fl_set_select_item(pObject, pPopupEntry):
14867 """ fl_set_select_item(pObject, pPopupEntry) -> pPopupReturn 14868 """ 14869 14870 _fl_set_select_item = cfuncproto( 14871 load_so_libforms(), "fl_set_select_item", 14872 cty.POINTER(FL_POPUP_RETURN), [cty.POINTER(FL_OBJECT), 14873 cty.POINTER(FL_POPUP_ENTRY)], 14874 """FL_POPUP_RETURN * fl_set_select_item(FL_OBJECT * p1, 14875 FL_POPUP_ENTRY * p2) 14876 """) 14877 keep_elem_refs(pObject, pPopupEntry) 14878 retval = _fl_set_select_item(pObject, pPopupEntry) 14879 return retval
14880 14881
14882 -def fl_get_select_item_by_value(pObject, value):
14883 """ fl_get_select_item_by_value(pObject, value) -> pPopupEntry 14884 """ 14885 14886 _fl_get_select_item_by_value = cfuncproto( 14887 load_so_libforms(), "fl_get_select_item_by_value", 14888 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), cty.c_long], 14889 """FL_POPUP_ENTRY * fl_get_select_item_by_value(FL_OBJECT * p1, 14890 long int p2) 14891 """) 14892 lvalue = convert_to_long(value) 14893 keep_elem_refs(pObject, value, lvalue) 14894 retval = _fl_get_select_item_by_value(pObject, lvalue) 14895 return retval
14896 14897
14898 -def fl_get_select_item_by_label(pObject, label):
14899 """ fl_get_select_item_by_label(pObject, label) -> pPopupEntry 14900 """ 14901 14902 _fl_get_select_item_by_label = cfuncproto( 14903 load_so_libforms(), "fl_get_select_item_by_label", 14904 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), STRING], 14905 """FL_POPUP_ENTRY * fl_get_select_item_by_label(FL_OBJECT * p1, 14906 const char * p2) 14907 """) 14908 slabel = convert_to_string(label) 14909 keep_elem_refs(pObject, label, slabel) 14910 retval = _fl_get_select_item_by_label(pObject, slabel) 14911 return retval
14912 14913
14914 -def fl_get_select_item_by_text(pObject, txtstr):
14915 """ fl_get_select_item_by_text(pObject, txtstr) -> pPopupEntry 14916 """ 14917 14918 _fl_get_select_item_by_text = cfuncproto( 14919 load_so_libforms(), "fl_get_select_item_by_text", 14920 cty.POINTER(FL_POPUP_ENTRY), [cty.POINTER(FL_OBJECT), STRING], 14921 """FL_POPUP_ENTRY * fl_get_select_item_by_text(FL_OBJECT * p1, 14922 const char * p2) 14923 """) 14924 stxtstr = convert_to_string(txtstr) 14925 keep_elem_refs(pObject, txtstr, stxtstr) 14926 retval = _fl_get_select_item_by_text(pObject, stxtstr) 14927 return retval
14928 14929
14930 -def fl_get_select_text_color(pObject):
14931 """ fl_get_select_text_color(pObject) -> color 14932 """ 14933 14934 _fl_get_select_text_color = cfuncproto( 14935 load_so_libforms(), "fl_get_select_text_color", 14936 FL_COLOR, [cty.POINTER(FL_OBJECT)], 14937 """FL_COLOR fl_get_select_text_color(FL_OBJECT * p1) 14938 """) 14939 keep_elem_refs(pObject) 14940 retval = _fl_get_select_text_color(pObject) 14941 return retval
14942 14943
14944 -def fl_set_select_text_color(pObject, colr):
14945 """ fl_set_select_text_color(pObject, colr) -> color 14946 """ 14947 14948 _fl_set_select_text_color = cfuncproto( 14949 load_so_libforms(), "fl_set_select_text_color", 14950 FL_COLOR, [cty.POINTER(FL_OBJECT), FL_COLOR], 14951 """FL_COLOR fl_set_select_text_color(FL_OBJECT * p1, FL_COLOR p2) 14952 """) 14953 ulcolr = convert_to_FL_COLOR(colr) 14954 keep_elem_refs(pObject, colr, ulcolr) 14955 retval = _fl_set_select_text_color(pObject, ulcolr) 14956 return retval
14957 14958 14959 #def fl_get_select_text_font(pObject, p2, p3) *API change*
14960 -def fl_get_select_text_font(pObject):
14961 """ fl_get_select_text_font(pObject) -> num, num1, num2 14962 """ 14963 14964 _fl_get_select_text_font = cfuncproto( 14965 load_so_libforms(), "fl_get_select_text_font", 14966 cty.c_int, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_int), 14967 cty.POINTER(cty.c_int)], 14968 """int fl_get_select_text_font(FL_OBJECT * p1, int * p2, int * p3) 14969 """) 14970 num1, pnum1 = make_int_and_pointer() 14971 num2, pnum2 = make_int_and_pointer() 14972 keep_elem_refs(pObject, num1, num2, pnum1, pnum2) 14973 retval = _fl_get_select_text_font(pObject, pnum2, pnum2) 14974 return retval, num1, num2
14975 14976
14977 -def fl_set_select_text_font(pObject, p2, p3):
14978 """ fl_set_select_text_font(pObject, p2, p3) -> font num. 14979 """ 14980 14981 _fl_set_select_text_font = cfuncproto( 14982 load_so_libforms(), "fl_set_select_text_font", 14983 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 14984 """int fl_set_select_text_font(FL_OBJECT * p1, int p2, int p3) 14985 """) 14986 ip2 = convert_to_int(p2) 14987 ip3 = convert_to_int(p3) 14988 keep_elem_refs(pObject, p2, p3, ip2, ip3) 14989 retval = _fl_set_select_text_font(pObject, ip2, ip3) 14990 return retval
14991 14992
14993 -def fl_get_select_text_align(pObject):
14994 """ fl_get_select_text_align(pObject) -> num. 14995 """ 14996 14997 _fl_get_select_text_align = cfuncproto( 14998 load_so_libforms(), "fl_get_select_text_align", 14999 cty.c_int, [cty.POINTER(FL_OBJECT)], 15000 """int fl_get_select_text_align(FL_OBJECT * p1) 15001 """) 15002 keep_elem_refs(pObject) 15003 retval = _fl_get_select_text_align(pObject) 15004 return retval
15005 15006
15007 -def fl_set_select_text_align(pObject, p2):
15008 """ fl_set_select_text_align(pObject, p2) -> num. 15009 """ 15010 15011 _fl_set_select_text_align = cfuncproto( 15012 load_so_libforms(), "fl_set_select_text_align", 15013 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 15014 """int fl_set_select_text_align(FL_OBJECT * p1, int p2) 15015 """) 15016 ip2 = convert_to_int(p2) 15017 keep_elem_refs(pObject, p2, ip2) 15018 retval = _fl_set_select_text_align(pObject, ip2) 15019 return retval
15020 15021
15022 -def fl_set_select_policy(pObject, num):
15023 """ fl_set_select_policy(pObject, num) -> num. 15024 """ 15025 15026 _fl_set_select_policy = cfuncproto( 15027 load_so_libforms(), "fl_set_select_policy", 15028 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 15029 """int fl_set_select_policy(FL_OBJECT * p1, int p2) 15030 """) 15031 inum = convert_to_int(num) 15032 keep_elem_refs(pObject, num, inum) 15033 retval = _fl_set_select_policy(pObject, inum) 15034 return retval
15035 15036 15037 15038 ####################### 15039 # forms.h (slider.h) 15040 # Object Class: Slider 15041 ####################### 15042 15043 # Routines 15044
15045 -def fl_create_slider(slidertype, x, y, w, h, label):
15046 """ fl_create_slider(slidertype, x, y, w, h, label) -> pObject 15047 """ 15048 15049 _fl_create_slider = cfuncproto( 15050 load_so_libforms(), "fl_create_slider", 15051 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 15052 FL_Coord, STRING], 15053 """FL_OBJECT * fl_create_slider(int type, FL_Coord x, FL_Coord y, 15054 FL_Coord w, FL_Coord h, const char * label) 15055 """) 15056 check_admitted_listvalues(slidertype, SLIDERTYPE_list) 15057 islidertype = convert_to_int(slidertype) 15058 ix = convert_to_FL_Coord(x) 15059 iy = convert_to_FL_Coord(y) 15060 iw = convert_to_FL_Coord(w) 15061 ih = convert_to_FL_Coord(h) 15062 slabel = convert_to_string(label) 15063 keep_elem_refs(slidertype, x, y, w, h, label, islidertype, ix, iy, 15064 iw, ih, slabel) 15065 retval = _fl_create_slider(islidertype, ix, iy, iw, ih, slabel) 15066 return retval
15067 15068
15069 -def fl_add_slider(slidertype, x, y, w, h, label):
15070 """ 15071 fl_add_slider(slidertype, x, y, w, h, label) -> pObject 15072 15073 Adds a slider to a form. No value is displayed. 15074 15075 @param slidertype : type of the slider 15076 @param x : horizontal position (upper-left corner) 15077 @param y : vertical position (upper-left corner) 15078 @param w : width of the slider 15079 @param h : height of the slider 15080 @param label : label of the slider (placed below it by default) 15081 """ 15082 15083 _fl_add_slider = cfuncproto( 15084 load_so_libforms(), "fl_add_slider", 15085 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 15086 FL_Coord, STRING], 15087 """FL_OBJECT * fl_add_slider(int type, FL_Coord x, FL_Coord y, 15088 FL_Coord w, FL_Coord h, const char * label) 15089 """) 15090 check_admitted_listvalues(slidertype, SLIDERTYPE_list) 15091 islidertype = convert_to_int(slidertype) 15092 ix = convert_to_FL_Coord(x) 15093 iy = convert_to_FL_Coord(y) 15094 iw = convert_to_FL_Coord(w) 15095 ih = convert_to_FL_Coord(h) 15096 slabel = convert_to_string(label) 15097 keep_elem_refs(slidertype, x, y, w, h, label, islidertype, ix, iy, 15098 iw, ih, slabel) 15099 retval = _fl_add_slider(islidertype, ix, iy, iw, ih, slabel) 15100 return retval
15101 15102
15103 -def fl_create_valslider(slidertype, x, y, w, h, label):
15104 """ fl_create_valslider(slidertype, x, y, w, h, label) -> pObject 15105 """ 15106 15107 _fl_create_valslider = cfuncproto( 15108 load_so_libforms(), "fl_create_valslider", 15109 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 15110 FL_Coord, STRING], 15111 """FL_OBJECT * fl_create_valslider(int type, FL_Coord x, 15112 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 15113 """) 15114 check_admitted_listvalues(slidertype, SLIDERTYPE_list) 15115 islidertype = convert_to_int(slidertype) 15116 ix = convert_to_FL_Coord(x) 15117 iy = convert_to_FL_Coord(y) 15118 iw = convert_to_FL_Coord(w) 15119 ih = convert_to_FL_Coord(h) 15120 slabel = convert_to_string(label) 15121 keep_elem_refs(slidertype, x, y, w, h, label, islidertype, ix, iy, 15122 iw, ih, slabel) 15123 retval = _fl_create_valslider(islidertype, ix, iy, iw, ih, slabel) 15124 return retval
15125 15126
15127 -def fl_add_valslider(slidertype, x, y, w, h, label):
15128 """ 15129 fl_add_valslider(slidertype, x, y, w, h, label) -> pObject 15130 15131 Adds a slider to a form. Its value is displayed above or to the 15132 left of the slider. 15133 15134 @param slidertype : type of the slider 15135 @param x : horizontal position (upper-left corner) 15136 @param y : vertical position (upper-left corner) 15137 @param w : width of the slider 15138 @param h : height of the slider 15139 @param label : label of the slider (placed below it by default) 15140 """ 15141 15142 _fl_add_valslider = cfuncproto( 15143 load_so_libforms(), "fl_add_valslider", 15144 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 15145 FL_Coord, STRING], 15146 """FL_OBJECT * fl_add_valslider(int type, FL_Coord x, FL_Coord y, 15147 FL_Coord w, FL_Coord h, const char * label) 15148 """) 15149 check_admitted_listvalues(slidertype, SLIDERTYPE_list) 15150 islidertype = convert_to_int(slidertype) 15151 ix = convert_to_FL_Coord(x) 15152 iy = convert_to_FL_Coord(y) 15153 iw = convert_to_FL_Coord(w) 15154 ih = convert_to_FL_Coord(h) 15155 slabel = convert_to_string(label) 15156 keep_elem_refs(slidertype, x, y, w, h, label, islidertype, ix, iy, 15157 iw, ih, slabel) 15158 retval = _fl_add_valslider(islidertype, ix, iy, iw, ih, slabel) 15159 return retval
15160 15161
15162 -def fl_set_slider_value(pObject, val):
15163 """ 15164 fl_set_slider_value(pObject, val) 15165 15166 Changes the value of a slider. 15167 15168 @param pObject : pointer to object 15169 @param val : new value of slider 15170 """ 15171 15172 _fl_set_slider_value = cfuncproto( 15173 load_so_libforms(), "fl_set_slider_value", 15174 None, [cty.POINTER(FL_OBJECT), cty.c_double], 15175 """void fl_set_slider_value(FL_OBJECT * ob, double val) 15176 """) 15177 fval = convert_to_double(val) 15178 keep_elem_refs(pObject, val, fval) 15179 _fl_set_slider_value(pObject, fval)
15180 15181
15182 -def fl_get_slider_value(pObject):
15183 """ 15184 fl_get_slider_value(pObject) -> value[float] 15185 15186 Returns value of a slider. 15187 15188 @param pObject : pointer to object 15189 """ 15190 15191 _fl_get_slider_value = cfuncproto( 15192 load_so_libforms(), "fl_get_slider_value", 15193 cty.c_double, [cty.POINTER(FL_OBJECT)], 15194 """double fl_get_slider_value(FL_OBJECT * ob) 15195 """) 15196 keep_elem_refs(pObject) 15197 retval = _fl_get_slider_value(pObject) 15198 return retval
15199 15200
15201 -def fl_set_slider_bounds(pObject, minbound, maxbound):
15202 """ 15203 fl_set_slider_bounds(pObject, minbound, maxbound) 15204 15205 Sets bounds/limits of a slider. 15206 15207 @param pObject : pointer to object 15208 @param minbound : minimum bound of slider 15209 @param maxbound : maximum bound of slider 15210 """ 15211 15212 _fl_set_slider_bounds = cfuncproto( 15213 load_so_libforms(), "fl_set_slider_bounds", 15214 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 15215 """void fl_set_slider_bounds(FL_OBJECT * ob, double min, 15216 double max) 15217 """) 15218 fminbound = convert_to_double(minbound) 15219 fmaxbound = convert_to_double(maxbound) 15220 keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 15221 _fl_set_slider_bounds(pObject, fminbound, fmaxbound)
15222 15223 15224 #def fl_get_slider_bounds(pObject, minbound, maxbound) *API change*
15225 -def fl_get_slider_bounds(pObject):
15226 """ 15227 fl_get_slider_bounds(pObject) -> minbound[float], maxbound[float] 15228 15229 Returns bounds/limits of a slider. 15230 15231 @param pObject : pointer to object 15232 """ 15233 15234 _fl_get_slider_bounds = cfuncproto( 15235 load_so_libforms(), "fl_get_slider_bounds", 15236 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 15237 cty.POINTER(cty.c_double)], 15238 """void fl_get_slider_bounds(FL_OBJECT * ob, double * min, 15239 double * max) 15240 """) 15241 minbound, pminbound = make_double_and_pointer() 15242 maxbound, pmaxbound = make_double_and_pointer() 15243 keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 15244 _fl_get_slider_bounds(pObject, pminbound, pmaxbound) 15245 return minbound, maxbound
15246 15247
15248 -def fl_set_slider_return(pObject, returnnum):
15249 """ 15250 fl_set_slider_return(pObject, returnnum) 15251 15252 Sets the return value of a slider. 15253 15254 @param pObject : pointer to object 15255 @param returnnum : value of return (e.g. xfc.FL_RETURN_NONE, etc..) 15256 """ 15257 15258 _fl_set_slider_return = cfuncproto( 15259 load_so_libforms(), "fl_set_slider_return", 15260 None, [cty.POINTER(FL_OBJECT), cty.c_int], 15261 """void fl_set_slider_return(FL_OBJECT * ob, int value) 15262 """) 15263 check_admitted_listvalues(returnnum, RETURN_list) 15264 ireturnnum = convert_to_int(returnnum) 15265 keep_elem_refs(pObject, returnnum, ireturnnum) 15266 _fl_set_slider_return(pObject, ireturnnum)
15267 15268
15269 -def fl_set_slider_step(pObject, value):
15270 """ fl_set_slider_step(pObject, value) 15271 """ 15272 15273 _fl_set_slider_step = cfuncproto( 15274 load_so_libforms(), "fl_set_slider_step", 15275 None, [cty.POINTER(FL_OBJECT), cty.c_double], 15276 """void fl_set_slider_step(FL_OBJECT * ob, double value) 15277 """) 15278 fvalue = convert_to_double(value) 15279 keep_elem_refs(pObject, value, fvalue) 15280 _fl_set_slider_step(pObject, fvalue)
15281 15282
15283 -def fl_set_slider_increment(pObject, leftbtnval, midlbtnval):
15284 """ fl_set_slider_increment(pObject, leftbtnval, midlbtnval) 15285 """ 15286 15287 _fl_set_slider_increment = cfuncproto( 15288 load_so_libforms(), "fl_set_slider_increment", 15289 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 15290 """void fl_set_slider_increment(FL_OBJECT * ob, double l, 15291 double r) 15292 """) 15293 fleftbtnval = convert_to_double(leftbtnval) 15294 fmidlbtnval = convert_to_double(midlbtnval) 15295 keep_elem_refs(pObject, leftbtnval, midlbtnval, fleftbtnval, fmidlbtnval) 15296 _fl_set_slider_increment(pObject, fleftbtnval, fmidlbtnval)
15297 15298 15299 #def fl_get_slider_increment(pObject, leftbtnval, midlbtnval) *API change*
15300 -def fl_get_slider_increment(pObject):
15301 """ fl_get_slider_increment(pObject) -> leftbtnval, midlbtnval 15302 """ 15303 15304 _fl_get_slider_increment = cfuncproto( 15305 load_so_libforms(), "fl_get_slider_increment", 15306 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 15307 cty.POINTER(cty.c_double)], \ 15308 """void fl_get_slider_increment(FL_OBJECT * ob, double * l, 15309 double * r) 15310 """) 15311 leftbtnval, pleftbtnval = make_double_and_pointer() 15312 midlbtnval, pmidlbtnval = make_double_and_pointer() 15313 keep_elem_refs(pObject, leftbtnval, midlbtnval, pleftbtnval, pmidlbtnval) 15314 _fl_get_slider_increment(pObject, pleftbtnval, pmidlbtnval) 15315 return leftbtnval, midlbtnval
15316 15317
15318 -def fl_set_slider_size(pObject, size):
15319 """ 15320 fl_set_slider_size(pObject, size) 15321 15322 Sets the size of a slider. 15323 15324 @param pObject : pointer to object 15325 @param size : value of size of the slider 15326 """ 15327 15328 _fl_set_slider_size = cfuncproto( 15329 load_so_libforms(), "fl_set_slider_size", 15330 None, [cty.POINTER(FL_OBJECT), cty.c_double], 15331 """void fl_set_slider_size(FL_OBJECT * ob, double size) 15332 """) 15333 fsize = convert_to_double(size) 15334 keep_elem_refs(pObject, size, fsize) 15335 _fl_set_slider_size(pObject, fsize)
15336 15337
15338 -def fl_set_slider_precision(pObject, precnum):
15339 """ 15340 fl_set_slider_precision(pObject, precnum) 15341 15342 Sets precision with which value a valslider is shown. 15343 15344 @param pObject : pointer to object 15345 @param precnum : precision of shown value 15346 """ 15347 15348 _fl_set_slider_precision = cfuncproto( 15349 load_so_libforms(), "fl_set_slider_precision", 15350 None, [cty.POINTER(FL_OBJECT), cty.c_int], 15351 """void fl_set_slider_precision(FL_OBJECT * ob, int prec) 15352 """) 15353 iprecnum = convert_to_int(precnum) 15354 keep_elem_refs(pObject, precnum, iprecnum) 15355 _fl_set_slider_precision(pObject, iprecnum)
15356 15357
15358 -def fl_set_slider_filter(pObject, py_ValFilter):
15359 """ 15360 fl_set_slider_filter(pObject, py_ValFilter) 15361 15362 Overrides the default (slider value shown in floating point format) 15363 by registering a filter function. 15364 15365 @param pObject : pointer to oject 15366 @param py_ValFilter : python function, fn(pObject, valfloat, 15367 intprecis) -> string 15368 """ 15369 15370 _fl_set_slider_filter = cfuncproto( 15371 load_so_libforms(), "fl_set_slider_filter", 15372 None, [cty.POINTER(FL_OBJECT), FL_VAL_FILTER], 15373 """void fl_set_slider_filter(FL_OBJECT * ob, FL_VAL_FILTER filter) 15374 """) 15375 c_ValFilter = FL_VAL_FILTER(py_ValFilter) 15376 keep_cfunc_refs(c_ValFilter, py_ValFilter) 15377 keep_elem_refs(pObject) 15378 _fl_set_slider_filter(pObject, c_ValFilter)
15379 15380
15381 -def fl_create_spinner(spinnertype, x, y, w, h, label):
15382 """ fl_create_spinner(spinnertype, x, y, w, h, label) -> pObject 15383 """ 15384 15385 _fl_create_spinner = cfuncproto( 15386 load_so_libforms(), "fl_create_spinner", 15387 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 15388 FL_Coord, STRING], 15389 """FL_OBJECT * fl_create_spinner(int type, FL_Coord x, FL_Coord y, 15390 FL_Coord w, FL_Coord h, const char * label) 15391 """) 15392 check_admitted_listvalues(spinnertype, SPINNERTYPE_list) 15393 ispinnertype = convert_to_int(spinnertype) 15394 ix = convert_to_FL_Coord(x) 15395 iy = convert_to_FL_Coord(y) 15396 iw = convert_to_FL_Coord(w) 15397 ih = convert_to_FL_Coord(h) 15398 slabel = convert_to_string(label) 15399 keep_elem_refs(spinnertype, x, y, w, h, label, ispinnertype, ix, iy, 15400 iw, ih, slabel) 15401 retval = _fl_create_spinner(ispinnertype, ix, iy, iw, ih, slabel) 15402 return retval
15403 15404
15405 -def fl_add_spinner(spinnertype, x, y, w, h, label):
15406 """ fl_add_spinner(spinnertype, x, y, w, h, label) -> pObject 15407 """ 15408 15409 _fl_add_spinner = cfuncproto( 15410 load_so_libforms(), "fl_add_spinner", 15411 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 15412 FL_Coord, STRING], 15413 """FL_OBJECT * fl_add_spinner(int type, FL_Coord x, FL_Coord y, 15414 FL_Coord w, FL_Coord h, const char * label) 15415 """) 15416 check_admitted_listvalues(spinnertype, SPINNERTYPE_list) 15417 ispinnertype = convert_to_int(spinnertype) 15418 ix = convert_to_FL_Coord(x) 15419 iy = convert_to_FL_Coord(y) 15420 iw = convert_to_FL_Coord(w) 15421 ih = convert_to_FL_Coord(h) 15422 slabel = convert_to_string(label) 15423 keep_elem_refs(spinnertype, x, y, w, h, label, ispinnertype, ix, iy, 15424 iw, ih, slabel) 15425 retval = _fl_add_spinner(ispinnertype, ix, iy, iw, ih, slabel) 15426 return retval
15427 15428
15429 -def fl_get_spinner_value(pObject):
15430 """ fl_get_spinner_value(pObject) -> floatval 15431 """ 15432 15433 _fl_get_spinner_value = cfuncproto( 15434 load_so_libforms(), "fl_get_spinner_value", 15435 cty.c_double, [cty.POINTER(FL_OBJECT)], 15436 """double fl_get_spinner_value(FL_OBJECT * obj) 15437 """) 15438 keep_elem_refs(pObject) 15439 retval = _fl_get_spinner_value(pObject) 15440 return retval
15441 15442
15443 -def fl_set_spinner_value(pObject, val):
15444 """ fl_set_spinner_value(pObject, val) -> num. 15445 """ 15446 15447 _fl_set_spinner_value = cfuncproto( 15448 load_so_libforms(), "fl_set_spinner_value", 15449 cty.c_double, [cty.POINTER(FL_OBJECT), cty.c_double], 15450 """double fl_set_spinner_value(FL_OBJECT * obj, double val) 15451 """) 15452 fval = convert_to_double(val) 15453 keep_elem_refs(pObject, val, fval) 15454 _fl_set_spinner_value(pObject, fval)
15455 15456
15457 -def fl_set_spinner_bounds(pObject, minbound, maxbound):
15458 """ fl_set_spinner_bounds(pObject, minbound, maxbound) 15459 """ 15460 15461 _fl_set_spinner_bounds = cfuncproto( 15462 load_so_libforms(), "fl_set_spinner_bounds", 15463 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 15464 """void fl_set_spinner_bounds(FL_OBJECT * obj, double min, 15465 double max) 15466 """) 15467 fminbound = convert_to_double(minbound) 15468 fmaxbound = convert_to_double(maxbound) 15469 keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 15470 _fl_set_spinner_bounds(pObject, fminbound, fmaxbound)
15471 15472 15473 #def fl_get_spinner_bounds(pObject, minbound, maxbound): *API change*
15474 -def fl_get_spinner_bounds(pObject):
15475 """ fl_get_spinner_bounds(pObject) -> minbound, maxbound 15476 """ 15477 15478 _fl_get_spinner_bounds = cfuncproto( 15479 load_so_libforms(), "fl_get_spinner_bounds", 15480 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 15481 cty.POINTER(cty.c_double)], \ 15482 """void fl_get_spinner_bounds(FL_OBJECT * obj, double * min, 15483 double * max) 15484 """) 15485 minbound, pminbound = make_double_and_pointer() 15486 maxbound, pmaxbound = make_double_and_pointer() 15487 keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 15488 _fl_get_spinner_bounds(pObject, pminbound, pmaxbound) 15489 return minbound, maxbound
15490 15491
15492 -def fl_set_spinner_step(pObject, step):
15493 """ fl_set_spinner_step(pObject, step) 15494 """ 15495 15496 _fl_set_spinner_step = cfuncproto( 15497 load_so_libforms(), "fl_set_spinner_step", 15498 None, [cty.POINTER(FL_OBJECT), cty.c_double], 15499 """void fl_set_spinner_step(FL_OBJECT * obj, double step) 15500 """) 15501 fstep = convert_to_double(step) 15502 keep_elem_refs(pObject, step, fstep) 15503 _fl_set_spinner_step(pObject, fstep)
15504 15505
15506 -def fl_get_spinner_step(pObject):
15507 """ fl_get_spinner_step(pObject) -> num. 15508 """ 15509 15510 _fl_get_spinner_step = cfuncproto( 15511 load_so_libforms(), "fl_get_spinner_step", 15512 cty.c_double, [cty.POINTER(FL_OBJECT)], 15513 """double fl_get_spinner_step(FL_OBJECT * obj) 15514 """) 15515 keep_elem_refs(pObject) 15516 retval = _fl_get_spinner_step(pObject) 15517 return retval
15518 15519
15520 -def fl_set_spinner_precision(pObject, precnum):
15521 """ fl_set_spinner_precision(pObject, precnum) 15522 """ 15523 15524 _fl_set_spinner_precision = cfuncproto( 15525 load_so_libforms(), "fl_set_spinner_precision", 15526 None, [cty.POINTER(FL_OBJECT), cty.c_int], 15527 """void fl_set_spinner_precision(FL_OBJECT * obj, int prec) 15528 """) 15529 iprecnum = convert_to_int(precnum) 15530 keep_elem_refs(pObject, precnum, iprecnum) 15531 _fl_set_spinner_precision(pObject, iprecnum)
15532 15533
15534 -def fl_get_spinner_precision(pObject):
15535 """ fl_get_spinner_precision(pObject) -> num. 15536 """ 15537 15538 _fl_get_spinner_precision = cfuncproto( 15539 load_so_libforms(), "fl_get_spinner_precision", 15540 cty.c_int, [cty.POINTER(FL_OBJECT)], 15541 """int fl_get_spinner_precision(FL_OBJECT * obj) 15542 """) 15543 keep_elem_refs(pObject) 15544 retval = _fl_get_spinner_precision(pObject) 15545 return retval
15546 15547
15548 -def fl_get_spinner_input(pObject):
15549 """ fl_get_spinner_input(pObject) -> pObject 15550 """ 15551 15552 _fl_get_spinner_input = cfuncproto( 15553 load_so_libforms(), "fl_get_spinner_input", 15554 cty.POINTER(FL_OBJECT), [cty.POINTER(FL_OBJECT)], 15555 """FL_OBJECT * fl_get_spinner_input(FL_OBJECT * obj) 15556 """) 15557 keep_elem_refs(pObject) 15558 retval = _fl_get_spinner_input(pObject) 15559 return retval
15560 15561
15562 -def fl_get_spinner_up_button(pObject):
15563 """ fl_get_spinner_up_button(pObject) -> pObject 15564 """ 15565 15566 _fl_get_spinner_up_button = cfuncproto( 15567 load_so_libforms(), "fl_get_spinner_up_button", 15568 cty.POINTER(FL_OBJECT), [cty.POINTER(FL_OBJECT)], 15569 """FL_OBJECT * fl_get_spinner_up_button(FL_OBJECT * obj) 15570 """) 15571 keep_elem_refs(pObject) 15572 retval = _fl_get_spinner_up_button(pObject) 15573 return retval
15574 15575
15576 -def fl_get_spinner_down_button(pObject):
15577 """ fl_get_spinner_down_button(pObject) -> pObject 15578 """ 15579 15580 _fl_get_spinner_down_button = cfuncproto( 15581 load_so_libforms(), "fl_get_spinner_down_button", 15582 cty.POINTER(FL_OBJECT), [cty.POINTER(FL_OBJECT)], 15583 """FL_OBJECT * fl_get_spinner_down_button(FL_OBJECT * obj) 15584 """) 15585 keep_elem_refs(pObject) 15586 retval = _fl_get_spinner_down_button(pObject) 15587 return retval
15588 15589 15590 15591 ######################## 15592 # forms.h (tabfolder.h) 15593 ######################## 15594
15595 -def fl_create_tabfolder(foldertype, x, y, w, h, label):
15596 """ fl_create_tabfolder(foldertype, x, y, w, h, label) -> pObject 15597 """ 15598 15599 _fl_create_tabfolder = cfuncproto( 15600 load_so_libforms(), "fl_create_tabfolder", 15601 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 15602 FL_Coord, STRING], 15603 """FL_OBJECT * fl_create_tabfolder(int type, FL_Coord x, 15604 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 15605 """) 15606 check_admitted_listvalues(foldertype, TABFOLDERTYPE_list) 15607 ifoldertype = convert_to_int(foldertype) 15608 ix = convert_to_FL_Coord(x) 15609 iy = convert_to_FL_Coord(y) 15610 iw = convert_to_FL_Coord(w) 15611 ih = convert_to_FL_Coord(h) 15612 slabel = convert_to_string(label) 15613 keep_elem_refs(foldertype, x, y, w, h, label, ifoldertype, ix, iy, 15614 iw, ih, slabel) 15615 retval = _fl_create_tabfolder(ifoldertype, ix, iy, iw, ih, slabel) 15616 return retval
15617 15618
15619 -def fl_add_tabfolder(foldertype, x, y, w, h, label):
15620 """ fl_add_tabfolder(foldertype, x, y, w, h, label) -> pObject 15621 """ 15622 15623 _fl_add_tabfolder = cfuncproto( 15624 load_so_libforms(), "fl_add_tabfolder", 15625 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 15626 FL_Coord, STRING], 15627 """FL_OBJECT * fl_add_tabfolder(int type, FL_Coord x, FL_Coord y, 15628 FL_Coord w, FL_Coord h, const char * label) 15629 """) 15630 check_admitted_listvalues(foldertype, TABFOLDERTYPE_list) 15631 ifoldertype = convert_to_int(foldertype) 15632 ix = convert_to_FL_Coord(x) 15633 iy = convert_to_FL_Coord(y) 15634 iw = convert_to_FL_Coord(w) 15635 ih = convert_to_FL_Coord(h) 15636 slabel = convert_to_string(label) 15637 keep_elem_refs(foldertype, x, y, w, h, label, ifoldertype, ix, iy, 15638 iw, ih, slabel) 15639 retval = _fl_add_tabfolder(ifoldertype, ix, iy, iw, ih, slabel) 15640 return retval
15641 15642
15643 -def fl_addto_tabfolder(pObject, title, pForm):
15644 """ fl_addto_tabfolder(pObject, title, pForm) -> pObject 15645 """ 15646 15647 _fl_addto_tabfolder = cfuncproto( 15648 load_so_libforms(), "fl_addto_tabfolder", 15649 cty.POINTER(FL_OBJECT), [cty.POINTER(FL_OBJECT), STRING, 15650 cty.POINTER(FL_FORM)], 15651 """FL_OBJECT * fl_addto_tabfolder(FL_OBJECT * ob, 15652 const char * title, FL_FORM * form) 15653 """) 15654 stitle = convert_to_string(title) 15655 keep_elem_refs(pObject, title, pForm, stitle) 15656 retval = _fl_addto_tabfolder(pObject, stitle, pForm) 15657 return retval
15658 15659
15660 -def fl_get_tabfolder_folder_bynumber(pObject, num):
15661 """ fl_get_tabfolder_folder_bynumber(pObject, num) -> pForm 15662 """ 15663 15664 _fl_get_tabfolder_folder_bynumber = cfuncproto( 15665 load_so_libforms(), "fl_get_tabfolder_folder_bynumber", 15666 cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT), cty.c_int], 15667 """FL_FORM * fl_get_tabfolder_folder_bynumber(FL_OBJECT * ob, 15668 int num) 15669 """) 15670 inum = convert_to_int(num) 15671 keep_elem_refs(pObject, num, inum) 15672 retval = _fl_get_tabfolder_folder_bynumber(pObject, inum) 15673 return retval
15674 15675
15676 -def fl_get_tabfolder_folder_byname(pObject, name):
15677 """ fl_get_tabfolder_folder_byname(pObject, name) -> pForm 15678 """ 15679 15680 _fl_get_tabfolder_folder_byname = cfuncproto( 15681 load_so_libforms(), "fl_get_tabfolder_folder_byname", 15682 cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT), STRING], 15683 """FL_FORM * fl_get_tabfolder_folder_byname(FL_OBJECT * ob, 15684 const char * name) 15685 """) 15686 sname = convert_to_string(name) 15687 keep_elem_refs(pObject, name, sname) 15688 retval = _fl_get_tabfolder_folder_byname(pObject, sname) 15689 return retval
15690 15691
15692 -def fl_delete_folder(pObject, pForm):
15693 """ fl_delete_folder(pObject, pForm) 15694 """ 15695 15696 _fl_delete_folder = cfuncproto( 15697 load_so_libforms(), "fl_delete_folder", 15698 None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_FORM)], 15699 """void fl_delete_folder(FL_OBJECT * ob, FL_FORM * form) 15700 """) 15701 keep_elem_refs(pObject, pForm) 15702 _fl_delete_folder(pObject, pForm)
15703 15704
15705 -def fl_delete_folder_bynumber(pObject, num):
15706 """ fl_delete_folder_bynumber(pObject, num) 15707 """ 15708 15709 _fl_delete_folder_bynumber = cfuncproto( 15710 load_so_libforms(), "fl_delete_folder_bynumber", 15711 None, [cty.POINTER(FL_OBJECT), cty.c_int], 15712 """void fl_delete_folder_bynumber(FL_OBJECT * ob, int num) 15713 """) 15714 inum = convert_to_int(num) 15715 keep_elem_refs(pObject, num, inum) 15716 _fl_delete_folder_bynumber(pObject, inum)
15717 15718
15719 -def fl_delete_folder_byname(pObject, name):
15720 """ fl_delete_folder_byname(pObject, name) 15721 """ 15722 15723 _fl_delete_folder_byname = cfuncproto( 15724 load_so_libforms(), "fl_delete_folder_byname", 15725 None, [cty.POINTER(FL_OBJECT), STRING], 15726 """void fl_delete_folder_byname(FL_OBJECT * ob, const char * name) 15727 """) 15728 sname = convert_to_string(name) 15729 keep_elem_refs(pObject, name, sname) 15730 _fl_delete_folder_byname(pObject, sname)
15731 15732
15733 -def fl_set_folder(pObject, pForm):
15734 """ fl_set_folder(pObject, pForm) 15735 """ 15736 15737 _fl_set_folder = cfuncproto( 15738 load_so_libforms(), "fl_set_folder", 15739 None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_FORM)], 15740 """void fl_set_folder(FL_OBJECT * ob, FL_FORM * form) 15741 """) 15742 keep_elem_refs(pObject, pForm) 15743 _fl_set_folder(pObject, pForm)
15744 15745
15746 -def fl_set_folder_byname(pObject, name):
15747 """ fl_set_folder_byname(pObject, name) 15748 """ 15749 15750 _fl_set_folder_byname = cfuncproto( 15751 load_so_libforms(), "fl_set_folder_byname", 15752 None, [cty.POINTER(FL_OBJECT), STRING], 15753 """void fl_set_folder_byname(FL_OBJECT * ob, const char * name) 15754 """) 15755 sname = convert_to_string(name) 15756 keep_elem_refs(pObject, name, sname) 15757 _fl_set_folder_byname(pObject, name)
15758 15759
15760 -def fl_set_folder_bynumber(pObject, num):
15761 """ fl_set_folder_bynumber(pObject, num) 15762 """ 15763 15764 _fl_set_folder_bynumber = cfuncproto( 15765 load_so_libforms(), "fl_set_folder_bynumber", 15766 None, [cty.POINTER(FL_OBJECT), cty.c_int], 15767 """void fl_set_folder_bynumber(FL_OBJECT * ob, int num) 15768 """) 15769 inum = convert_to_int(num) 15770 keep_elem_refs(pObject, num, inum) 15771 _fl_set_folder_bynumber(pObject, inum)
15772 15773
15774 -def fl_get_folder(pObject):
15775 """ 15776 fl_get_folder(pObject) -> pForm 15777 15778 @param pObject : pointer to object 15779 """ 15780 15781 _fl_get_folder = cfuncproto( 15782 load_so_libforms(), "fl_get_folder", 15783 cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT)], 15784 """FL_FORM * fl_get_folder(FL_OBJECT * ob) 15785 """) 15786 keep_elem_refs(pObject) 15787 retval = _fl_get_folder(pObject) 15788 return retval
15789 15790
15791 -def fl_get_folder_number(pObject):
15792 """ 15793 fl_get_folder_number(pObject) -> folder num. 15794 15795 @param pObject : pointer to object 15796 """ 15797 15798 _fl_get_folder_number = cfuncproto( 15799 load_so_libforms(), "fl_get_folder_number", 15800 cty.c_int, [cty.POINTER(FL_OBJECT)], 15801 """int fl_get_folder_number(FL_OBJECT * ob) 15802 """) 15803 keep_elem_refs(pObject) 15804 retval = _fl_get_folder_number(pObject) 15805 return retval
15806 15807
15808 -def fl_get_folder_name(pObject):
15809 """ 15810 fl_get_folder_name(pObject) -> name string 15811 15812 @param pObject : pointer to object 15813 """ 15814 15815 _fl_get_folder_name = cfuncproto( 15816 load_so_libforms(), "fl_get_folder_name", 15817 STRING, [cty.POINTER(FL_OBJECT)], 15818 """const char * fl_get_folder_name(FL_OBJECT * ob) 15819 """) 15820 keep_elem_refs(pObject) 15821 retval = _fl_get_folder_name(pObject) 15822 return retval
15823 15824
15825 -def fl_get_tabfolder_numfolders(pObject):
15826 """ 15827 fl_get_tabfolder_numfolders(pObject) -> num. 15828 15829 @param pObject : pointer to object 15830 """ 15831 15832 _fl_get_tabfolder_numfolders = cfuncproto( 15833 load_so_libforms(), "fl_get_tabfolder_numfolders", 15834 cty.c_int, [cty.POINTER(FL_OBJECT)], 15835 """int fl_get_tabfolder_numfolders(FL_OBJECT * ob) 15836 """) 15837 keep_elem_refs(pObject) 15838 retval = _fl_get_tabfolder_numfolders(pObject) 15839 return retval
15840 15841
15842 -def fl_get_active_folder(pObject):
15843 """ 15844 fl_get_active_folder(pObject) -> pForm 15845 15846 @param pObject : pointer to object 15847 """ 15848 15849 _fl_get_active_folder = cfuncproto( 15850 load_so_libforms(), "fl_get_active_folder", 15851 cty.POINTER(FL_FORM), [cty.POINTER(FL_OBJECT)], 15852 """FL_FORM * fl_get_active_folder(FL_OBJECT * ob) 15853 """) 15854 keep_elem_refs(pObject) 15855 retval = _fl_get_active_folder(pObject) 15856 return retval
15857 15858
15859 -def fl_get_active_folder_number(pObject):
15860 """ 15861 fl_get_active_folder_number(pObject) -> num. 15862 15863 @param pObject : pointer to object 15864 """ 15865 15866 _fl_get_active_folder_number = cfuncproto( 15867 load_so_libforms(), "fl_get_active_folder_number", 15868 cty.c_int, [cty.POINTER(FL_OBJECT)], 15869 """int fl_get_active_folder_number(FL_OBJECT * ob) 15870 """) 15871 keep_elem_refs(pObject) 15872 retval = _fl_get_active_folder_number(pObject) 15873 return retval
15874 15875
15876 -def fl_get_active_folder_name(pObject):
15877 """ 15878 fl_get_active_folder_name(pObject) -> name string 15879 15880 @param pObject : pointer to object 15881 """ 15882 15883 _fl_get_active_folder_name = cfuncproto( 15884 load_so_libforms(), "fl_get_active_folder_name", 15885 STRING, [cty.POINTER(FL_OBJECT)], 15886 """const char * fl_get_active_folder_name(FL_OBJECT * ob) 15887 """) 15888 keep_elem_refs(pObject) 15889 retval = _fl_get_active_folder_name(pObject) 15890 return retval
15891 15892 15893 #def fl_get_folder_area(pObject, x, y, w, h) *API change*
15894 -def fl_get_folder_area(pObject):
15895 """ 15896 fl_get_folder_area(pObject) -> x, y, w, h 15897 15898 @param pObject : pointer to object 15899 """ 15900 15901 _fl_get_folder_area = cfuncproto( 15902 load_so_libforms(), "fl_get_folder_area", 15903 None, [cty.POINTER(FL_OBJECT), cty.POINTER(FL_Coord), 15904 cty.POINTER(FL_Coord), cty.POINTER(FL_Coord), 15905 cty.POINTER(FL_Coord)], 15906 """void fl_get_folder_area(FL_OBJECT * ob, FL_Coord * x, 15907 FL_Coord * y, FL_Coord * w, FL_Coord * h) 15908 """) 15909 x, px = make_int_and_pointer() 15910 y, py = make_int_and_pointer() 15911 w, pw = make_int_and_pointer() 15912 h, ph = make_int_and_pointer() 15913 keep_elem_refs(pObject, x, y, w, h, px, py, pw, ph) 15914 _fl_get_folder_area(pObject, px, py, pw, ph) 15915 return x, y, w, h
15916 15917
15918 -def fl_replace_folder_bynumber(pObject, num, pForm):
15919 """ 15920 fl_replace_folder_bynumber(pObject, num, pForm) 15921 15922 @param pObject : pointer to object 15923 """ 15924 15925 _fl_replace_folder_bynumber = cfuncproto( 15926 load_so_libforms(), "fl_replace_folder_bynumber", 15927 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.POINTER(FL_FORM)], 15928 """void fl_replace_folder_bynumber(FL_OBJECT * ob, int num, 15929 FL_FORM * form) 15930 """) 15931 inum = convert_to_int(num) 15932 keep_elem_refs(pObject, num, pForm, inum) 15933 _fl_replace_folder_bynumber(pObject, inum, pForm)
15934 15935
15936 -def fl_set_tabfolder_autofit(pObject, num):
15937 """ 15938 fl_set_tabfolder_autofit(pObject, num) -> num. 15939 15940 @param pObject : pointer to object 15941 """ 15942 15943 _fl_set_tabfolder_autofit = cfuncproto( 15944 load_so_libforms(), "fl_set_tabfolder_autofit", 15945 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 15946 """int fl_set_tabfolder_autofit(FL_OBJECT * ob, int y) 15947 """) 15948 inum = convert_to_int(num) 15949 keep_elem_refs(pObject, num, inum) 15950 retval = _fl_set_tabfolder_autofit(pObject, inum) 15951 return retval
15952 15953
15954 -def fl_set_default_tabfolder_corner(npixels):
15955 """ 15956 fl_set_default_tabfolder_corner(npixels) -> old pixels num. 15957 15958 Adjusts the corner pixels, changing appearance of the tabs. 15959 15960 @param npixels : number of corner pixels (default 3) 15961 """ 15962 15963 _fl_set_default_tabfolder_corner = cfuncproto( 15964 load_so_libforms(), "fl_set_default_tabfolder_corner", 15965 cty.c_int, [cty.c_int], 15966 """int fl_set_default_tabfolder_corner(int n): 15967 """) 15968 ipixels = convert_to_int(npixels) 15969 keep_elem_refs(npixels, ipixels) 15970 retval = _fl_set_default_tabfolder_corner(ipixels) 15971 return retval
15972 15973
15974 -def fl_set_tabfolder_offset(pObject, offset):
15975 """ 15976 fl_set_tabfolder_offset(pObject, offset) -> num. 15977 15978 @param pObject : pointer to tabfolder object 15979 """ 15980 15981 _fl_set_tabfolder_offset = cfuncproto( 15982 load_so_libforms(), "fl_set_tabfolder_offset", 15983 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 15984 """int fl_set_tabfolder_offset(FL_OBJECT * ob, int offset) 15985 """) 15986 ioffset = convert_to_int(offset) 15987 keep_elem_refs(pObject, offset, ioffset) 15988 retval = _fl_set_tabfolder_offset(pObject, ioffset) 15989 return retval
15990 15991 15992 15993 ################### 15994 # forms.h (text.h) 15995 ################### 15996
15997 -def fl_create_text(texttype, x, y, w, h, label):
15998 """ 15999 fl_create_text(texttype, x, y, w, h, label) -> pObject 16000 """ 16001 16002 _fl_create_text = cfuncproto( 16003 load_so_libforms(), "fl_create_text", 16004 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 16005 FL_Coord, STRING], 16006 """FL_OBJECT * fl_create_text(int type, FL_Coord x, FL_Coord y, 16007 FL_Coord w, FL_Coord h, const char * label) 16008 """) 16009 check_admitted_listvalues(texttype, TEXTTYPE_list) 16010 itexttype = convert_to_int(texttype) 16011 ix = convert_to_FL_Coord(x) 16012 iy = convert_to_FL_Coord(y) 16013 iw = convert_to_FL_Coord(w) 16014 ih = convert_to_FL_Coord(h) 16015 slabel = convert_to_string(label) 16016 keep_elem_refs(texttype, x, y, w, h, label, itexttype, ix, iy, 16017 iw, ih, slabel) 16018 retval = _fl_create_text(itexttype, ix, iy, iw, ih, slabel) 16019 return retval
16020 16021
16022 -def fl_add_text(texttype, x, y, w, h, label):
16023 """ 16024 fl_add_text(texttype, x, y, w, h, label) -> pObject 16025 """ 16026 16027 _fl_add_text = cfuncproto( 16028 load_so_libforms(), "fl_add_text", 16029 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 16030 FL_Coord, STRING], 16031 """FL_OBJECT * fl_add_text(int type, FL_Coord x, FL_Coord y, 16032 FL_Coord w, FL_Coord h, const char * label) 16033 """) 16034 check_admitted_listvalues(texttype, TEXTTYPE_list) 16035 itexttype = convert_to_int(texttype) 16036 ix = convert_to_FL_Coord(x) 16037 iy = convert_to_FL_Coord(y) 16038 iw = convert_to_FL_Coord(w) 16039 ih = convert_to_FL_Coord(h) 16040 slabel = convert_to_string(label) 16041 keep_elem_refs(texttype, x, y, w, h, label, itexttype, ix, iy, 16042 iw, ih, slabel) 16043 retval = _fl_add_text(itexttype, ix, iy, iw, ih, slabel) 16044 return retval
16045 16046 16047 16048 ######################### 16049 # forms.h (thumbwheel.h) 16050 ######################### 16051
16052 -def fl_get_thumbwheel_value(pObject):
16053 """ 16054 fl_get_thumbwheel_value(pObject) -> num. 16055 16056 @param pObject : pointer to object 16057 """ 16058 16059 _fl_get_thumbwheel_value = cfuncproto( 16060 load_so_libforms(), "fl_get_thumbwheel_value", 16061 cty.c_double, [cty.POINTER(FL_OBJECT)], 16062 """double fl_get_thumbwheel_value(FL_OBJECT * ob) 16063 """) 16064 keep_elem_refs(pObject) 16065 retval = _fl_get_thumbwheel_value(pObject) 16066 return retval
16067 16068
16069 -def fl_set_thumbwheel_value(pObject, value):
16070 """ 16071 fl_set_thumbwheel_value(pObject, value) 16072 16073 @param pObject : pointer to object 16074 """ 16075 16076 _fl_set_thumbwheel_value = cfuncproto( 16077 load_so_libforms(), "fl_set_thumbwheel_value", 16078 cty.c_double, [cty.POINTER(FL_OBJECT), cty.c_double], 16079 """double fl_set_thumbwheel_value(FL_OBJECT * ob, double value) 16080 """) 16081 fvalue = convert_to_double(value) 16082 keep_elem_refs(pObject, value, fvalue) 16083 retval = _fl_set_thumbwheel_value(pObject, fvalue) 16084 return retval
16085 16086
16087 -def fl_get_thumbwheel_step(pObject):
16088 """ 16089 fl_get_thumbwheel_step(pObject) -> num. 16090 16091 @param pObject : pointer to object 16092 """ 16093 16094 _fl_get_thumbwheel_step = cfuncproto( 16095 load_so_libforms(), "fl_get_thumbwheel_step", 16096 cty.c_double, [cty.POINTER(FL_OBJECT)], 16097 """double fl_get_thumbwheel_step(FL_OBJECT * ob) 16098 """) 16099 keep_elem_refs(pObject) 16100 retval = _fl_get_thumbwheel_step(pObject) 16101 return retval
16102 16103
16104 -def fl_set_thumbwheel_step(pObject, step):
16105 """ 16106 fl_set_thumbwheel_step(pObject, step) -> num. 16107 16108 @param pObject : pointer to object 16109 """ 16110 16111 _fl_set_thumbwheel_step = cfuncproto( 16112 load_so_libforms(), "fl_set_thumbwheel_step", 16113 cty.c_double, [cty.POINTER(FL_OBJECT), cty.c_double], 16114 """double fl_set_thumbwheel_step(FL_OBJECT * ob, double step) 16115 """) 16116 fstep = convert_to_double(step) 16117 keep_elem_refs(pObject, step, fstep) 16118 retval = _fl_set_thumbwheel_step(pObject, fstep) 16119 return retval
16120 16121
16122 -def fl_set_thumbwheel_return(pObject, when):
16123 """ 16124 fl_set_thumbwheel_return(pObject, when) -> num. 16125 16126 @param pObject : pointer to object 16127 """ 16128 16129 _fl_set_thumbwheel_return = cfuncproto( 16130 load_so_libforms(), "fl_set_thumbwheel_return", 16131 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 16132 """int fl_set_thumbwheel_return(FL_OBJECT * ob, int how) 16133 """) 16134 check_admitted_listvalues(when, RETURN_list) 16135 iwhen = convert_to_int(when) 16136 keep_elem_refs(pObject, when, iwhen) 16137 retval = _fl_set_thumbwheel_return(pObject, when) 16138 return retval
16139 16140
16141 -def fl_set_thumbwheel_crossover(pObject, flag):
16142 """ 16143 fl_set_thumbwheel_crossover(pObject, flag) -> num. 16144 16145 @param pObject : pointer to object 16146 """ 16147 16148 _fl_set_thumbwheel_crossover = cfuncproto( 16149 load_so_libforms(), "fl_set_thumbwheel_crossover", 16150 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 16151 """int fl_set_thumbwheel_crossover(FL_OBJECT * ob, int flag) 16152 """) 16153 iflag = convert_to_int(flag) 16154 keep_elem_refs(pObject, flag, iflag) 16155 retval = _fl_set_thumbwheel_crossover(pObject, iflag) 16156 return retval
16157 16158
16159 -def fl_set_thumbwheel_bounds(pObject, minbound, maxbound):
16160 """ 16161 fl_set_thumbwheel_bounds(pObject, minbound, maxbound) 16162 16163 @param pObject : pointer to object 16164 """ 16165 16166 _fl_set_thumbwheel_bounds = cfuncproto( 16167 load_so_libforms(), "fl_set_thumbwheel_bounds", 16168 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 16169 """void fl_set_thumbwheel_bounds(FL_OBJECT * ob, double min, 16170 double max) 16171 """) 16172 fminbound = convert_to_double(minbound) 16173 fmaxbound = convert_to_double(maxbound) 16174 keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 16175 _fl_set_thumbwheel_bounds(pObject, fminbound, fmaxbound)
16176 16177 16178 #def fl_get_thumbwheel_bounds(pObject, minbound, maxbound) *API change*
16179 -def fl_get_thumbwheel_bounds(pObject):
16180 """ 16181 fl_get_thumbwheel_bounds(pObject) -> minbound, maxbound 16182 16183 @param pObject : pointer to thumbwheel object 16184 """ 16185 16186 _fl_get_thumbwheel_bounds = cfuncproto( 16187 load_so_libforms(), "fl_get_thumbwheel_bounds", 16188 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 16189 cty.POINTER(cty.c_double)], 16190 """void fl_get_thumbwheel_bounds(FL_OBJECT * ob, double * min, 16191 double * max) 16192 """) 16193 minbound, pminbound = make_double_and_pointer() 16194 maxbound, pmaxbound = make_double_and_pointer() 16195 keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 16196 _fl_get_thumbwheel_bounds(pObject, pminbound, pmaxbound) 16197 return minbound, maxbound
16198 16199
16200 -def fl_create_thumbwheel(wheeltype, x, y, w, h, label):
16201 """ 16202 fl_create_thumbwheel(wheeltype, x, y, w, h, label) -> pObject 16203 """ 16204 16205 _fl_create_thumbwheel = cfuncproto( 16206 load_so_libforms(), "fl_create_thumbwheel", 16207 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 16208 FL_Coord, STRING], 16209 """FL_OBJECT * fl_create_thumbwheel(int type, FL_Coord x, 16210 FL_Coord y, FL_Coord w, FL_Coord h, const char * label) 16211 """) 16212 check_admitted_listvalues(wheeltype, THUMBWHEELTYPE_list) 16213 iwheeltype = convert_to_int(wheeltype) 16214 ix = convert_to_FL_Coord(x) 16215 iy = convert_to_FL_Coord(y) 16216 iw = convert_to_FL_Coord(w) 16217 ih = convert_to_FL_Coord(h) 16218 slabel = convert_to_string(label) 16219 keep_elem_refs(wheeltype, x, y, w, h, label, iwheeltype, ix, iy, 16220 iw, ih, slabel) 16221 retval = _fl_create_thumbwheel(iwheeltype, ix, iy, iw, ih, slabel) 16222 return retval
16223 16224
16225 -def fl_add_thumbwheel(wheeltype, x, y, w, h, label):
16226 """ 16227 fl_add_thumbwheel(wheeltype, x, y, w, h, label) -> pObject 16228 """ 16229 16230 _fl_add_thumbwheel = cfuncproto( 16231 load_so_libforms(), "fl_add_thumbwheel", 16232 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 16233 FL_Coord, STRING], 16234 """FL_OBJECT * fl_add_thumbwheel(int type, FL_Coord x, FL_Coord y, 16235 FL_Coord w, FL_Coord h, const char * label) 16236 """) 16237 check_admitted_listvalues(wheeltype, THUMBWHEELTYPE_list) 16238 iwheeltype = convert_to_int(wheeltype) 16239 ix = convert_to_FL_Coord(x) 16240 iy = convert_to_FL_Coord(y) 16241 iw = convert_to_FL_Coord(w) 16242 ih = convert_to_FL_Coord(h) 16243 slabel = convert_to_string(label) 16244 keep_elem_refs(wheeltype, x, y, w, h, label, iwheeltype, ix, iy, 16245 iw, ih, slabel) 16246 retval = _fl_add_thumbwheel(iwheeltype, ix, iy, iw, ih, slabel) 16247 return retval
16248 16249 16250 16251 ###################### 16252 # forms.h (timer.h) 16253 # Object Class: Timer 16254 ###################### 16255 16256 # Routines 16257
16258 -def fl_create_timer(timertype, x, y, w, h, label):
16259 """ 16260 fl_create_timer(timertype, x, y, w, h, label) -> pObject 16261 """ 16262 16263 _fl_create_timer = cfuncproto( 16264 load_so_libforms(), "fl_create_timer", 16265 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 16266 FL_Coord, STRING], 16267 """FL_OBJECT * fl_create_timer(int type, FL_Coord x, FL_Coord y, 16268 FL_Coord w, FL_Coord h, const char * label) 16269 """) 16270 check_admitted_listvalues(timertype, TIMERTYPE_list) 16271 itimertype = convert_to_int(timertype) 16272 ix = convert_to_FL_Coord(x) 16273 iy = convert_to_FL_Coord(y) 16274 iw = convert_to_FL_Coord(w) 16275 ih = convert_to_FL_Coord(h) 16276 slabel = convert_to_string(label) 16277 keep_elem_refs(timertype, x, y, w, h, label, itimertype, ix, iy, 16278 iw, ih, slabel) 16279 retval = _fl_create_timer(itimertype, ix, iy, iw, ih, slabel) 16280 return retval
16281 16282
16283 -def fl_add_timer(timertype, x, y, w, h, label):
16284 """ 16285 fl_add_timer(timertype, x, y, w, h, label) -> pObject 16286 """ 16287 16288 _fl_add_timer = cfuncproto( 16289 load_so_libforms(), "fl_add_timer", 16290 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 16291 FL_Coord, STRING], 16292 """FL_OBJECT * fl_add_timer(int type, FL_Coord x, FL_Coord y, 16293 FL_Coord w, FL_Coord h, const char * label) 16294 """) 16295 check_admitted_listvalues(timertype, TIMERTYPE_list) 16296 itimertype = convert_to_int(timertype) 16297 ix = convert_to_FL_Coord(x) 16298 iy = convert_to_FL_Coord(y) 16299 iw = convert_to_FL_Coord(w) 16300 ih = convert_to_FL_Coord(h) 16301 slabel = convert_to_string(label) 16302 keep_elem_refs(timertype, x, y, w, h, label, itimertype, ix, iy, 16303 iw, ih, slabel) 16304 retval = _fl_add_timer(itimertype, ix, iy, iw, ih, slabel) 16305 return retval
16306 16307
16308 -def fl_set_timer(pObject, total):
16309 """ 16310 fl_set_timer(pObject, total) 16311 16312 @param pObject : pointer to object 16313 """ 16314 16315 _fl_set_timer = cfuncproto( 16316 load_so_libforms(), "fl_set_timer", 16317 None, [cty.POINTER(FL_OBJECT), cty.c_double], 16318 """void fl_set_timer(FL_OBJECT * ob, double total) 16319 """) 16320 ftotal = convert_to_double(total) 16321 keep_elem_refs(pObject, total, ftotal) 16322 _fl_set_timer(pObject, ftotal)
16323 16324
16325 -def fl_get_timer(pObject):
16326 """ 16327 fl_get_timer(pObject) -> num. 16328 16329 @param pObject : pointer to object 16330 """ 16331 16332 _fl_get_timer = cfuncproto( 16333 load_so_libforms(), "fl_get_timer", 16334 cty.c_double, [cty.POINTER(FL_OBJECT)], 16335 """double fl_get_timer(FL_OBJECT * ob) 16336 """) 16337 keep_elem_refs(pObject) 16338 retval = _fl_get_timer(pObject) 16339 return retval
16340 16341
16342 -def fl_set_timer_countup(pObject, yes):
16343 """ 16344 fl_set_timer_countup(pObject, yes) 16345 16346 @param pObject : pointer to object 16347 """ 16348 16349 _fl_set_timer_countup = cfuncproto( 16350 load_so_libforms(), "fl_set_timer_countup", 16351 None, [cty.POINTER(FL_OBJECT), cty.c_int], 16352 """void fl_set_timer_countup(FL_OBJECT * ob, int yes) 16353 """) 16354 iyes = convert_to_int(yes) 16355 keep_elem_refs(pObject, yes, iyes) 16356 _fl_set_timer_countup(pObject, iyes)
16357 16358 16359 FL_TIMER_FILTER = cty.CFUNCTYPE(STRING, cty.POINTER(FL_OBJECT), cty.c_double) 16360
16361 -def fl_set_timer_filter(pObject, py_TimerFilter):
16362 """ 16363 fl_set_timer_filter(pObject, py_TimerFilter) -> timer_filter func. 16364 16365 @param pObject : pointer to object 16366 @param py_TimerFilter : python function, fn(pObject, valfloat) -> 16367 string 16368 """ 16369 16370 _fl_set_timer_filter = cfuncproto( 16371 load_so_libforms(), "fl_set_timer_filter", 16372 FL_TIMER_FILTER, [cty.POINTER(FL_OBJECT), FL_TIMER_FILTER], 16373 """FL_TIMER_FILTER fl_set_timer_filter(FL_OBJECT * ob, 16374 FL_TIMER_FILTER filter) 16375 """) 16376 c_TimerFilter = FL_TIMER_FILTER(py_TimerFilter) 16377 keep_cfunc_refs(c_TimerFilter, py_TimerFilter) 16378 keep_elem_refs(pObject) 16379 retval = _fl_set_timer_filter(pObject, c_TimerFilter) 16380 return retval
16381 16382
16383 -def fl_suspend_timer(pObject):
16384 """ 16385 fl_suspend_timer(pObject) 16386 16387 @param pObject : pointer to object 16388 """ 16389 16390 _fl_suspend_timer = cfuncproto( 16391 load_so_libforms(), "fl_suspend_timer", 16392 None, [cty.POINTER(FL_OBJECT)], 16393 """void fl_suspend_timer(FL_OBJECT * ob) 16394 """) 16395 keep_elem_refs(pObject) 16396 _fl_suspend_timer(pObject)
16397 16398
16399 -def fl_resume_timer(pObject):
16400 """ 16401 fl_resume_timer(pObject) 16402 16403 Resume timer previously paused. 16404 16405 @param pObject : pointer to timer object 16406 """ 16407 16408 _fl_resume_timer = cfuncproto( 16409 load_so_libforms(), "fl_resume_timer", 16410 None, [cty.POINTER(FL_OBJECT)], 16411 """void fl_resume_timer(FL_OBJECT * ob) 16412 """) 16413 keep_elem_refs(pObject) 16414 _fl_resume_timer(pObject)
16415 16416 16417 16418 ############################### 16419 # forms.h (xpopup.h) 16420 # Prototypes for xpop-up menus 16421 ############################### 16422
16423 -def fl_setpup_entries(popupid, pPopupEntry):
16424 """ 16425 fl_setpup_entries(popupid, pPopupEntry) -> num. 16426 """ 16427 16428 _fl_setpup_entries = cfuncproto( 16429 load_so_libforms(), "fl_setpup_entries", 16430 cty.c_int, [cty.c_int, cty.POINTER(FL_PUP_ENTRY)], 16431 """int fl_setpup_entries(int nm, FL_PUP_ENTRY * entries) 16432 """) 16433 ipopupid = convert_to_int(popupid) 16434 keep_elem_refs(popupid, pPopupEntry, ipopupid) 16435 retval = _fl_setpup_entries(ipopupid, pPopupEntry) 16436 return retval
16437 16438
16439 -def fl_newpup(win):
16440 """ 16441 fl_newpup(win) -> num. 16442 """ 16443 16444 _fl_newpup = cfuncproto( 16445 load_so_libforms(), "fl_newpup", 16446 cty.c_int, [Window], 16447 """int fl_newpup(Window win) 16448 """) 16449 ulwin = convert_to_Window(win) 16450 keep_elem_refs(win, ulwin) 16451 retval = _fl_newpup(ulwin) 16452 return retval
16453 16454
16455 -def fl_defpup(win, pupstr):
16456 """ 16457 fl_defpup(win, pupstr) -> num. 16458 """ 16459 16460 _fl_defpup = cfuncproto( 16461 load_so_libforms(), "fl_defpup", 16462 cty.c_int, [Window, STRING], 16463 """int fl_defpup(Window win, const char * str): 16464 """) 16465 ulwin = convert_to_Window(win) 16466 spupstr = convert_to_string(pupstr) 16467 keep_elem_refs(win, pupstr, ulwin, spupstr) 16468 retval = _fl_defpup(ulwin, spupstr) 16469 return retval
16470 16471
16472 -def fl_addtopup(popupid, pupstr):
16473 """ 16474 fl_addtopup(popupid, pupstr) -> num. 16475 """ 16476 16477 _fl_addtopup = cfuncproto( 16478 load_so_libforms(), "fl_addtopup", 16479 cty.c_int, [cty.c_int, STRING], 16480 """int fl_addtopup(int n, const char * str) 16481 """) 16482 ipopupid = convert_to_int(popupid) 16483 spupstr = convert_to_string(pupstr) 16484 keep_elem_refs(popupid, pupstr, ipopupid, spupstr) 16485 retval = _fl_addtopup(ipopupid, spupstr) 16486 return retval
16487 16488
16489 -def fl_setpup_mode(popupid, itemval, mode):
16490 """ 16491 fl_setpup_mode(popupid, itemval, mode) -> num. 16492 """ 16493 16494 _fl_setpup_mode = cfuncproto( 16495 load_so_libforms(), "fl_setpup_mode", 16496 cty.c_int, [cty.c_int, cty.c_int, cty.c_uint], 16497 """int fl_setpup_mode(int nm, int ni, unsigned int mode) 16498 """) 16499 ipopupid = convert_to_int(popupid) 16500 iitemval = convert_to_int(itemval) 16501 uimode = convert_to_uint(mode) 16502 keep_elem_refs(popupid, itemval, mode, ipopupid, iitemval, uimode) 16503 retval = _fl_setpup_mode(ipopupid, iitemval, uimode) 16504 return retval
16505 16506
16507 -def fl_freepup(popupid):
16508 """ 16509 fl_freepup(popupid) 16510 """ 16511 16512 _fl_freepup = cfuncproto( 16513 load_so_libforms(), "fl_freepup", 16514 None, [cty.c_int], 16515 """void fl_freepup(int n) 16516 """) 16517 ipopupid = convert_to_int(popupid) 16518 keep_elem_refs(popupid, ipopupid) 16519 _fl_freepup(ipopupid)
16520 16521
16522 -def fl_dopup(popupid):
16523 """ 16524 fl_dopup(popupid) -> num. 16525 """ 16526 16527 _fl_dopup = cfuncproto( 16528 load_so_libforms(), "fl_dopup", 16529 cty.c_int, [cty.c_int], 16530 """int fl_dopup(int n) 16531 """) 16532 ipopupid = convert_to_int(popupid) 16533 keep_elem_refs(popupid, ipopupid) 16534 retval = _fl_dopup(ipopupid) 16535 return retval
16536 16537
16538 -def fl_setpup_default_cursor(cursor):
16539 """ 16540 fl_setpup_default_cursor(cursor) -> cursor 16541 """ 16542 16543 _fl_setpup_default_cursor = cfuncproto( 16544 load_so_libforms(), "fl_setpup_default_cursor", 16545 Cursor, [cty.c_int], 16546 """Cursor fl_setpup_default_cursor(int cursor): 16547 """) 16548 icursor = convert_to_int(cursor) 16549 keep_elem_refs(cursor, icursor) 16550 retval = _fl_setpup_default_cursor(icursor) 16551 return retval
16552 16553
16554 -def fl_setpup_default_color(fgcolr, bgcolr):
16555 """ 16556 fl_setpup_default_color(fgcolr, bgcolr) 16557 """ 16558 16559 _fl_setpup_default_color = cfuncproto( 16560 load_so_libforms(), "fl_setpup_default_color", 16561 None, [FL_COLOR, FL_COLOR], 16562 """void fl_setpup_default_color(FL_COLOR fg, FL_COLOR bg) 16563 """) 16564 ulfgcolr = convert_to_FL_COLOR(fgcolr) 16565 ulbgcolr = convert_to_FL_COLOR(bgcolr) 16566 keep_elem_refs(fgcolr, bgcolr, ulfgcolr, ulbgcolr) 16567 _fl_setpup_default_color(ulfgcolr, ulbgcolr)
16568 16569
16570 -def fl_setpup_default_pup_checked_color(colr):
16571 """ 16572 fl_setpup_default_pup_checked_color(colr): 16573 """ 16574 16575 _fl_setpup_default_pup_checked_color = cfuncproto( 16576 load_so_libforms(), "fl_setpup_default_pup_checked_color", 16577 None, [FL_COLOR], 16578 """void fl_setpup_default_pup_checked_color(FL_COLOR col) 16579 """) 16580 ulcolr = convert_to_FL_COLOR(colr) 16581 keep_elem_refs(colr, ulcolr) 16582 _fl_setpup_default_pup_checked_color(ulcolr)
16583 16584
16585 -def fl_setpup_default_fontsize(size):
16586 """ 16587 fl_setpup_default_fontsize(size) -> num. 16588 """ 16589 16590 _fl_setpup_default_fontsize = cfuncproto( 16591 load_so_libforms(), "fl_setpup_default_fontsize", 16592 cty.c_int, [cty.c_int], 16593 """int fl_setpup_default_fontsize(int size) DEPRECATED? 16594 """) 16595 isize = convert_to_int(size) 16596 keep_elem_refs(size, isize) 16597 retval = _fl_setpup_default_fontsize(isize) 16598 return retval
16599 16600
16601 -def fl_setpup_default_fontstyle(style):
16602 """ 16603 fl_setpup_default_fontstyle(style) -> num. 16604 """ 16605 16606 _fl_setpup_default_fontstyle = cfuncproto( 16607 load_so_libforms(), "fl_setpup_default_fontstyle", 16608 cty.c_int, [cty.c_int], 16609 """int fl_setpup_default_fontstyle(int style) 16610 """) 16611 istyle = convert_to_int(style) 16612 keep_elem_refs(style, istyle) 16613 retval = _fl_setpup_default_fontstyle(istyle) 16614 return retval
16615 16616 16617 fl_setpup_fontsize = fl_setpup_default_fontsize 16618 fl_setpup_fontstyle = fl_setpup_default_fontstyle 16619 fl_setpup_color = fl_setpup_default_color 16620 fl_setpup_default_checkcolor = fl_setpup_default_pup_checked_color 16621 fl_setpup_checkcolor = fl_setpup_default_pup_checked_color 16622 16623
16624 -def fl_setpup_default_bw(bw):
16625 """ 16626 fl_setpup_default_bw(bw) -> num. 16627 """ 16628 16629 _fl_setpup_default_bw = cfuncproto( 16630 load_so_libforms(), "fl_setpup_default_bw", 16631 cty.c_int, [cty.c_int], 16632 """int fl_setpup_default_bw(int bw): 16633 """) 16634 ibw = convert_to_int(bw) 16635 keep_elem_refs(bw, ibw) 16636 retval = _fl_setpup_default_bw(ibw) 16637 return retval
16638 16639
16640 -def fl_setpup_shortcut(popupid, itemval, hotkeystxt):
16641 """ 16642 fl_setpup_shortcut(popupid, itemval, hotkeystxt) 16643 """ 16644 16645 _fl_setpup_shortcut = cfuncproto( 16646 load_so_libforms(), "fl_setpup_shortcut", 16647 None, [cty.c_int, cty.c_int, STRING], 16648 """void fl_setpup_shortcut(int nm, int ni, const char * sc) 16649 """) 16650 ipopupid = convert_to_int(popupid) 16651 iitemval = convert_to_int(itemval) 16652 shotkeystxt = convert_to_string(hotkeystxt) 16653 keep_elem_refs(popupid, itemval, hotkeystxt, ipopupid, iitemval, \ 16654 shotkeystxt) 16655 _fl_setpup_shortcut(ipopupid, iitemval, shotkeystxt)
16656 16657
16658 -def fl_setpup_position(x, y):
16659 """ 16660 fl_setpup_position(x, y) 16661 """ 16662 16663 _fl_setpup_position = cfuncproto( 16664 load_so_libforms(), "fl_setpup_position", 16665 None, [cty.c_int, cty.c_int], 16666 """void fl_setpup_position(int x, int y) 16667 """) 16668 ix = convert_to_int(x) 16669 iy = convert_to_int(y) 16670 keep_elem_refs(x, y, ix, iy) 16671 _fl_setpup_position(ix, iy)
16672 16673
16674 -def fl_setpup_selection(popupid, itemval):
16675 """ 16676 fl_setpup_selection(popupid, itemval) 16677 """ 16678 16679 _fl_setpup_selection = cfuncproto( 16680 load_so_libforms(), "fl_setpup_selection", 16681 None, [cty.c_int, cty.c_int], 16682 """void fl_setpup_selection(int nm, int ni) 16683 """) 16684 ipopupid = convert_to_int(popupid) 16685 iitemval = convert_to_int(itemval) 16686 keep_elem_refs(popupid, itemval, ipopupid, iitemval) 16687 _fl_setpup_selection(ipopupid, iitemval)
16688 16689
16690 -def fl_setpup_shadow(popupid, flag):
16691 """ 16692 fl_setpup_shadow(popupid, flag) 16693 """ 16694 16695 _fl_setpup_shadow = cfuncproto( 16696 load_so_libforms(), "fl_setpup_shadow", 16697 None, [cty.c_int, cty.c_int], 16698 """void fl_setpup_shadow(int n, int y) 16699 """) 16700 ipopupid = convert_to_int(popupid) 16701 iflag = convert_to_int(flag) 16702 keep_elem_refs(popupid, flag, ipopupid, iflag) 16703 _fl_setpup_shadow(ipopupid, iflag)
16704 16705
16706 -def fl_setpup_softedge(popupid, flag):
16707 """ 16708 fl_setpup_softedge(popupid, flag) 16709 """ 16710 16711 _fl_setpup_softedge = cfuncproto( 16712 load_so_libforms(), "fl_setpup_softedge", 16713 None, [cty.c_int, cty.c_int], 16714 """void fl_setpup_softedge(int n, int y) 16715 """) 16716 ipopupid = convert_to_int(popupid) 16717 iflag = convert_to_int(flag) 16718 keep_elem_refs(popupid, flag, ipopupid, iflag) 16719 _fl_setpup_softedge(ipopupid, iflag)
16720 16721
16722 -def fl_setpup_bw(popupid, bw):
16723 """ 16724 fl_setpup_bw(popupid, bw) 16725 """ 16726 16727 _fl_setpup_bw = cfuncproto( 16728 load_so_libforms(), "fl_setpup_bw", 16729 None, [cty.c_int, cty.c_int], 16730 """void fl_setpup_bw(int n, int bw) 16731 """) 16732 ipopupid = convert_to_int(popupid) 16733 ibw = convert_to_int(bw) 16734 keep_elem_refs(popupid, bw, ipopupid, ibw) 16735 _fl_setpup_bw(ipopupid, ibw)
16736 16737
16738 -def fl_setpup_title(popupid, title):
16739 """ 16740 fl_setpup_title(popupid, title) 16741 """ 16742 16743 _fl_setpup_title = cfuncproto( 16744 load_so_libforms(), "fl_setpup_title", 16745 None, [cty.c_int, STRING], 16746 """void fl_setpup_title(int nm, const char * title) 16747 """) 16748 ipopupid = convert_to_int(popupid) 16749 stitle = convert_to_string(title) 16750 keep_elem_refs(popupid, title, ipopupid, stitle) 16751 _fl_setpup_title(ipopupid, stitle)
16752 16753 16754 FL_PUP_ENTERCB = cty.CFUNCTYPE(None, cty.c_int, cty.c_void_p) 16755
16756 -def fl_setpup_entercb(popupid, py_PupEnterCb, data):
16757 """ 16758 fl_setpup_entercb(popupid, py_PupEnterCb, data) -> pup_entercb 16759 """ 16760 16761 _fl_setpup_entercb = cfuncproto( 16762 load_so_libforms(), "fl_setpup_entercb", 16763 FL_PUP_ENTERCB, [cty.c_int, FL_PUP_ENTERCB, cty.c_void_p], 16764 """FL_PUP_ENTERCB fl_setpup_entercb(int nm, FL_PUP_ENTERCB cb, 16765 void * data) 16766 """) 16767 ipopupid = convert_to_int(popupid) 16768 c_PupEnterCb = FL_PUP_ENTERCB(py_PupEnterCb) 16769 pdata = cty.cast(data, cty.c_void_p) 16770 keep_cfunc_refs(c_PupEnterCb, py_PupEnterCb) 16771 keep_elem_refs(popupid, data, ipopupid, pdata) 16772 retval = _fl_setpup_entercb(ipopupid, c_PupEnterCb, pdata) 16773 return retval
16774 16775 16776 FL_PUP_LEAVECB = cty.CFUNCTYPE(None, cty.c_int, cty.c_void_p) 16777
16778 -def fl_setpup_leavecb(popupid, py_LeaveCb, data):
16779 """ 16780 fl_setpup_leavecb(popupid, py_LeaveCb, data) -> pup_leavecb 16781 """ 16782 16783 _fl_setpup_leavecb = cfuncproto( 16784 load_so_libforms(), "fl_setpup_leavecb", 16785 FL_PUP_LEAVECB, [cty.c_int, FL_PUP_LEAVECB, cty.c_void_p], 16786 """FL_PUP_LEAVECB fl_setpup_leavecb(int nm, FL_PUP_LEAVECB cb, 16787 void * data) 16788 """) 16789 ipopupid = convert_to_int(popupid) 16790 c_LeaveCb = FL_PUP_LEAVECB(py_LeaveCb) 16791 pdata = cty.cast(data, cty.c_void_p) 16792 keep_cfunc_refs(c_LeaveCb, py_LeaveCb) 16793 keep_elem_refs(popupid, data, ipopupid, pdata) 16794 retval = _fl_setpup_leavecb(ipopupid, c_LeaveCb, pdata) 16795 return retval
16796 16797
16798 -def fl_setpup_pad(popupid, padw, padh):
16799 """ 16800 fl_setpup_pad(popupid, padw, padh) 16801 """ 16802 16803 _fl_setpup_pad = cfuncproto( 16804 load_so_libforms(), "fl_setpup_pad", 16805 None, [cty.c_int, cty.c_int, cty.c_int], 16806 """void fl_setpup_pad(int n, int padw, int padh) 16807 """) 16808 ipopupid = convert_to_int(popupid) 16809 ipadw = convert_to_int(padw) 16810 ipadh = convert_to_int(padh) 16811 keep_elem_refs(popupid, padw, padh, ipopupid, ipadw, ipadh) 16812 _fl_setpup_pad(ipopupid, ipadw, ipadh)
16813 16814
16815 -def fl_setpup_cursor(popupid, cursor):
16816 """ 16817 fl_setpup_cursor(popupid, cursor) -> cursor 16818 """ 16819 16820 _fl_setpup_cursor = cfuncproto( 16821 load_so_libforms(), "fl_setpup_cursor", 16822 Cursor, [cty.c_int, cty.c_int], 16823 """Cursor fl_setpup_cursor(int nm, int cursor) 16824 """) 16825 ipopupid = convert_to_int(popupid) 16826 icursor = convert_to_int(cursor) 16827 keep_elem_refs(popupid, cursor, ipopupid, icursor) 16828 retval = _fl_setpup_cursor(ipopupid, icursor) 16829 return retval
16830 16831
16832 -def fl_setpup_maxpup(newmaxnum):
16833 """ 16834 fl_setpup_maxpup(newmaxnum) -> num. 16835 """ 16836 16837 _fl_setpup_maxpup = cfuncproto( 16838 load_so_libforms(), "fl_setpup_maxpup", 16839 cty.c_int, [cty.c_int], 16840 """int fl_setpup_maxpup(int n) 16841 """) 16842 inewmaxnum = convert_to_int(newmaxnum) 16843 keep_elem_refs(newmaxnum, inewmaxnum) 16844 retval = _fl_setpup_maxpup(inewmaxnum) 16845 return retval
16846 16847
16848 -def fl_getpup_mode(popupid, itemval):
16849 """ 16850 fl_getpup_mode(popupid, itemval) -> num. 16851 """ 16852 16853 _fl_getpup_mode = cfuncproto( 16854 load_so_libforms(), "fl_getpup_mode", 16855 cty.c_uint, [cty.c_int, cty.c_int], 16856 """unsigned int fl_getpup_mode(int nm, int ni) 16857 """) 16858 ipopupid = convert_to_int(popupid) 16859 iitemval = convert_to_int(itemval) 16860 keep_elem_refs(popupid, itemval, ipopupid, iitemval) 16861 retval = _fl_getpup_mode(ipopupid, iitemval) 16862 return retval
16863 16864
16865 -def fl_getpup_text(popupid, itemval):
16866 """ 16867 fl_getpup_text(popupid, itemval) -> text string 16868 """ 16869 16870 _fl_getpup_text = cfuncproto( 16871 load_so_libforms(), "fl_getpup_text", 16872 STRING, [cty.c_int, cty.c_int], 16873 """const char * fl_getpup_text(int nm, int ni) 16874 """) 16875 ipopupid = convert_to_int(popupid) 16876 iitemval = convert_to_int(itemval) 16877 keep_elem_refs(popupid, itemval, ipopupid, iitemval) 16878 retval = _fl_getpup_text(ipopupid, iitemval) 16879 return retval
16880 16881
16882 -def fl_showpup(popupid):
16883 """ 16884 fl_showpup(popupid) 16885 """ 16886 16887 _fl_showpup = cfuncproto( 16888 load_so_libforms(), "fl_showpup", 16889 None, [cty.c_int], 16890 """void fl_showpup(int n) 16891 """) 16892 ipopupid = convert_to_int(popupid) 16893 keep_elem_refs(popupid, ipopupid) 16894 _fl_showpup(ipopupid)
16895 16896
16897 -def fl_hidepup(popupid):
16898 """ 16899 fl_hidepup(popupid) 16900 """ 16901 16902 _fl_hidepup = cfuncproto( 16903 load_so_libforms(), "fl_hidepup", 16904 None, [cty.c_int], 16905 """void fl_hidepup(int n) 16906 """) 16907 ipopupid = convert_to_int(popupid) 16908 keep_elem_refs(popupid, ipopupid) 16909 _fl_hidepup(ipopupid)
16910 16911
16912 -def fl_getpup_items(popupid):
16913 """ 16914 fl_getpup_items(popupid) -> num. 16915 """ 16916 16917 _fl_getpup_items = cfuncproto( 16918 load_so_libforms(), "fl_getpup_items", 16919 cty.c_int, [cty.c_int], 16920 """int fl_getpup_items(int n) 16921 """) 16922 ipopupid = convert_to_int(popupid) 16923 keep_elem_refs(popupid, ipopupid) 16924 retval = _fl_getpup_items(ipopupid) 16925 return retval
16926 16927
16928 -def fl_current_pup():
16929 """ 16930 fl_current_pup() -> num. 16931 """ 16932 16933 _fl_current_pup = cfuncproto( 16934 load_so_libforms(), "fl_current_pup", 16935 cty.c_int, [], 16936 """int fl_current_pup() 16937 """) 16938 retval = _fl_current_pup() 16939 return retval
16940 16941
16942 -def fl_setpup_itemcb(popupid, itemval, py_PupCb):
16943 """ 16944 fl_setpup_itemcb(popupid, itemval, py_PupCb) -> pup_cb 16945 """ 16946 16947 _fl_setpup_itemcb = cfuncproto( 16948 load_so_libforms(), "fl_setpup_itemcb", 16949 FL_PUP_CB, [cty.c_int, cty.c_int, FL_PUP_CB], 16950 """FL_PUP_CB fl_setpup_itemcb(int nm, int ni, FL_PUP_CB cb) 16951 """) 16952 ipopupid = convert_to_int(popupid) 16953 iitemval = convert_to_int(itemval) 16954 c_PupCb = FL_PUP_CB(py_PupCb) 16955 keep_cfunc_refs(c_PupCb, py_PupCb) 16956 keep_elem_refs(popupid, itemval, ipopupid, iitemval) 16957 retval = _fl_setpup_itemcb(ipopupid, iitemval, c_PupCb) 16958 return retval
16959 16960
16961 -def fl_setpup_menucb(popupid, py_PupCb):
16962 """ fl_setpup_menucb(popupid, py_PupCb) -> pup_cb func. 16963 """ 16964 16965 _fl_setpup_menucb = cfuncproto( 16966 load_so_libforms(), "fl_setpup_menucb", 16967 FL_PUP_CB, [cty.c_int, FL_PUP_CB], 16968 """FL_PUP_CB fl_setpup_menucb(int nm, FL_PUP_CB cb) 16969 """) 16970 ipopupid = convert_to_int(popupid) 16971 c_PupCb = FL_PUP_CB(py_PupCb) 16972 keep_cfunc_refs(c_PupCb, py_PupCb) 16973 keep_elem_refs(popupid, ipopupid) 16974 retval = _fl_setpup_menucb(ipopupid, c_PupCb) 16975 return retval
16976 16977
16978 -def fl_setpup_submenu(popupid, itemval, subpopupid):
16979 """ 16980 fl_setpup_submenu(popupid, itemval, subpopupid) 16981 """ 16982 16983 _fl_setpup_submenu = cfuncproto( 16984 load_so_libforms(), "fl_setpup_submenu", 16985 None, [cty.c_int, cty.c_int, cty.c_int], 16986 """void fl_setpup_submenu(int m, int i, int subm) 16987 """) 16988 ipopupid = convert_to_int(popupid) 16989 iitemval = convert_to_int(itemval) 16990 isubpopupid = convert_to_int(subpopupid) 16991 keep_elem_refs(popupid, itemval, subpopupid, ipopupid, iitemval, \ 16992 isubpopupid) 16993 _fl_setpup_submenu(ipopupid, iitemval, isubpopupid)
16994 16995 16996 fl_setpup = fl_setpup_mode 16997 16998 16999 # Others 17000
17001 -def fl_create_xyplot(plottype, x, y, w, h, label):
17002 """ 17003 fl_create_xyplot(plottype, x, y, w, h, label) -> pObject 17004 """ 17005 17006 _fl_create_xyplot = cfuncproto( 17007 load_so_libforms(), "fl_create_xyplot", 17008 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 17009 FL_Coord, STRING], 17010 """FL_OBJECT * fl_create_xyplot(int t, FL_Coord x, FL_Coord y, 17011 FL_Coord w, FL_Coord h, const char * label) 17012 """) 17013 check_admitted_listvalues(plottype, XYPLOTTYPE_list) 17014 iplottype = convert_to_int(plottype) 17015 ix = convert_to_FL_Coord(x) 17016 iy = convert_to_FL_Coord(y) 17017 iw = convert_to_FL_Coord(w) 17018 ih = convert_to_FL_Coord(h) 17019 slabel = convert_to_string(label) 17020 keep_elem_refs(plottype, x, y, w, h, label, iplottype, ix, iy, 17021 iw, ih, slabel) 17022 retval = _fl_create_xyplot(iplottype, ix, iy, iw, ih, slabel) 17023 return retval
17024 17025
17026 -def fl_add_xyplot(plottype, x, y, w, h, label):
17027 """ 17028 fl_add_xyplot(plottype, x, y, w, h, label) -> pObject 17029 """ 17030 17031 _fl_add_xyplot = cfuncproto( 17032 load_so_libforms(), "fl_add_xyplot", 17033 cty.POINTER(FL_OBJECT), [cty.c_int, FL_Coord, FL_Coord, FL_Coord, 17034 FL_Coord, STRING], 17035 """FL_OBJECT * fl_add_xyplot(int t, FL_Coord x, FL_Coord y, 17036 FL_Coord w, FL_Coord h, const char * label) 17037 """) 17038 check_admitted_listvalues(plottype, XYPLOTTYPE_list) 17039 iplottype = convert_to_int(plottype) 17040 ix = convert_to_FL_Coord(x) 17041 iy = convert_to_FL_Coord(y) 17042 iw = convert_to_FL_Coord(w) 17043 ih = convert_to_FL_Coord(h) 17044 slabel = convert_to_string(label) 17045 keep_elem_refs(plottype, x, y, w, h, label, iplottype, ix, iy, 17046 iw, ih, slabel) 17047 retval = _fl_add_xyplot(iplottype, ix, iy, iw, ih, slabel) 17048 return retval
17049 17050
17051 -def fl_set_xyplot_data(pObject, xlist, ylist, n, title, xlabel, ylabel):
17052 """ fl_set_xyplot_data(pObject, xlist, ylist, n, title, xlabel, ylabel) 17053 17054 @param pObject : pointer to object 17055 """ 17056 17057 _fl_set_xyplot_data = cfuncproto( 17058 load_so_libforms(), "fl_set_xyplot_data", 17059 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 17060 cty.POINTER(cty.c_float), cty.c_int, STRING, STRING, STRING], 17061 """void fl_set_xyplot_data(FL_OBJECT * ob, float * x, float * y, 17062 int n, const char * title, const char * xlabel, 17063 const char * ylabel) 17064 """) 17065 #px = cty.cast(x, cty.POINTER(cty.c_float)) 17066 print xlist, xlist[0] 17067 fx = [] 17068 for a in range(xlist): 17069 fx[a] = convert_to_float(xlist[a]) 17070 px = cty.pointer(fx) 17071 print "x, fx, px", xlist, fx, px 17072 #py = cty.cast(y, cty.POINTER(cty.c_float)) 17073 fy = [] 17074 for a in range(ylist): 17075 fy[a] = convert_to_float(ylist[a]) 17076 py = cty.pointer(fy) 17077 print "y, fy, py", ylist, fy, py 17078 inum = convert_to_int(n) 17079 stitle = convert_to_string(title) 17080 sxlabel = convert_to_string(xlabel) 17081 sylabel = convert_to_string(ylabel) 17082 keep_elem_refs(pObject, xlist, ylist, n, fx, fy, px, py, title, \ 17083 xlabel, ylabel, inum, stitle, sxlabel, sylabel) 17084 _fl_set_xyplot_data(pObject, px, py, inum, stitle, sxlabel, sylabel)
17085 17086
17087 -def fl_set_xyplot_data_double(pObject, x, y, n, title, xlabel, ylabel):
17088 """ fl_set_xyplot_data_double(pObject, x, y, n, title, xlabel, ylabel) 17089 17090 @param pObject : pointer to object 17091 """ 17092 17093 _fl_set_xyplot_data_double = cfuncproto( 17094 load_so_libforms(), "fl_set_xyplot_data_double", 17095 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_double), 17096 cty.POINTER(cty.c_double), cty.c_int, STRING, STRING, STRING], 17097 """void fl_set_xyplot_data_double(FL_OBJECT * ob, double * x, 17098 double * y, int n, const char * title, const char * xlabel, 17099 const char * ylabel) 17100 """) 17101 px = cty.cast(x, cty.POINTER(cty.c_double)) 17102 py = cty.cast(y, cty.POINTER(cty.c_double)) 17103 inum = convert_to_int(n) 17104 stitle = convert_to_string(title) 17105 sxlabel = convert_to_string(xlabel) 17106 sylabel = convert_to_string(ylabel) 17107 keep_elem_refs(pObject, x, y, n, title, xlabel, ylabel, px, py, inum, \ 17108 stitle, sxlabel, sylabel) 17109 _fl_set_xyplot_data_double(pObject, px, py, n, title, \ 17110 xlabel, ylabel, inum, stitle, \ 17111 sxlabel, sylabel)
17112 17113
17114 -def fl_set_xyplot_file(pObject, f, title, xl, yl):
17115 """ fl_set_xyplot_file(pObject, f, title, xl, yl) -> num. 17116 17117 @param pObject : pointer to object 17118 """ 17119 17120 _fl_set_xyplot_file = cfuncproto( 17121 load_so_libforms(), "fl_set_xyplot_file", 17122 cty.c_int, [cty.POINTER(FL_OBJECT), STRING, STRING, STRING, 17123 STRING], 17124 """int fl_set_xyplot_file(FL_OBJECT * ob, const char * f, 17125 const char * title, const char * xl, const char * yl) 17126 """) 17127 sf = convert_to_string(f) 17128 stitle = convert_to_string(title) 17129 sxl = convert_to_string(xl) 17130 syl = convert_to_string(yl) 17131 keep_elem_refs(pObject, f, title, xl, yl, sf, stitle, sxl, syl) 17132 retval = _fl_set_xyplot_file(pObject, sf, stitle, sxl, syl) 17133 return retval
17134 17135
17136 -def fl_insert_xyplot_data(pObject, idnum, n, valx, valy):
17137 """ fl_insert_xyplot_data(pObject, idnum, n, valx, valy) 17138 17139 @param pObject : pointer to object 17140 """ 17141 17142 _fl_insert_xyplot_data = cfuncproto( 17143 load_so_libforms(), "fl_insert_xyplot_data", 17144 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int, cty.c_double, 17145 cty.c_double], 17146 """void fl_insert_xyplot_data(FL_OBJECT * ob, int id, int n, 17147 double x, double y) 17148 """) 17149 iidnum = convert_to_int(idnum) 17150 inum = convert_to_int(n) 17151 fvalx = convert_to_double(valx) 17152 fvaly = convert_to_double(valy) 17153 keep_elem_refs(pObject, idnum, n, valx, valy, iidnum, inum, fvalx, fvaly) 17154 _fl_insert_xyplot_data(pObject, iidnum, inum, fvalx, fvaly)
17155 17156
17157 -def fl_add_xyplot_text(pObject, valx, valy, text, al, colr):
17158 """ fl_add_xyplot_text(pObject, valx, valy, text, al, colr) 17159 17160 @param pObject : pointer to object 17161 """ 17162 17163 _fl_add_xyplot_text = cfuncproto( 17164 load_so_libforms(), "fl_add_xyplot_text", 17165 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double, STRING, 17166 cty.c_int, FL_COLOR], 17167 """void fl_add_xyplot_text(FL_OBJECT * ob, double x, double y, 17168 const char * text, int al, FL_COLOR col) 17169 """) 17170 fvalx = convert_to_double(valx) 17171 fvaly = convert_to_double(valy) 17172 stext = convert_to_string(text) 17173 ial = convert_to_int(al) 17174 ulcolr = convert_to_FL_COLOR(colr) 17175 keep_elem_refs(pObject, valx, valy, text, al, colr, fvalx, fvaly, \ 17176 stext, ial, ulcolr) 17177 _fl_add_xyplot_text(pObject, fvalx, fvaly, stext, ial, ulcolr)
17178 17179
17180 -def fl_delete_xyplot_text(pObject, text):
17181 """ fl_delete_xyplot_text(pObject, text) 17182 17183 @param pObject : pointer to object 17184 """ 17185 17186 _fl_delete_xyplot_text = cfuncproto( 17187 load_so_libforms(), "fl_delete_xyplot_text", 17188 None, [cty.POINTER(FL_OBJECT), STRING], 17189 """void fl_delete_xyplot_text(FL_OBJECT * ob, const char * text) 17190 """) 17191 stext = convert_to_string(text) 17192 keep_elem_refs(pObject, text, stext) 17193 _fl_delete_xyplot_text(pObject, stext)
17194 17195
17196 -def fl_set_xyplot_maxoverlays(pObject, maxover):
17197 """ fl_set_xyplot_maxoverlays(pObject, maxover) -> num. 17198 17199 @param pObject : pointer to object 17200 """ 17201 17202 _fl_set_xyplot_maxoverlays = cfuncproto( 17203 load_so_libforms(), "fl_set_xyplot_maxoverlays", 17204 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 17205 """int fl_set_xyplot_maxoverlays(FL_OBJECT * ob, int maxover) 17206 """) 17207 imaxover = convert_to_int(maxover) 17208 keep_elem_refs(pObject, maxover, imaxover) 17209 retval = _fl_set_xyplot_maxoverlays(pObject, imaxover) 17210 return retval
17211 17212
17213 -def fl_add_xyplot_overlay(pObject, idnum, x, y, n, colr):
17214 """ fl_add_xyplot_overlay(pObject, idnum, x, y, n, colr) 17215 17216 @param pObject : pointer to object 17217 """ 17218 17219 _fl_add_xyplot_overlay = cfuncproto( 17220 load_so_libforms(), "fl_add_xyplot_overlay", 17221 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.POINTER(cty.c_float), 17222 cty.POINTER(cty.c_float), cty.c_int, FL_COLOR], 17223 """void fl_add_xyplot_overlay(FL_OBJECT * ob, int id, float * x, 17224 float * y, int n, FL_COLOR col) 17225 """) 17226 iidnum = convert_to_int(idnum) 17227 px = cty.cast(x, cty.POINTER(cty.c_float)) 17228 py = cty.cast(y, cty.POINTER(cty.c_float)) 17229 inum = convert_to_int(n) 17230 ulcolr = convert_to_FL_COLOR(colr) 17231 keep_elem_refs(pObject, idnum, x, y, n, colr, iidnum, px, py, inum, \ 17232 ulcolr) 17233 _fl_add_xyplot_overlay(pObject, iidnum, px, py, inum, ulcolr)
17234 17235
17236 -def fl_add_xyplot_overlay_file(pObject, idnum, f, colr):
17237 """ fl_add_xyplot_overlay_file(pObject, idnum, f, colr) -> num. 17238 17239 @param pObject : pointer to object 17240 """ 17241 17242 _fl_add_xyplot_overlay_file = cfuncproto( 17243 load_so_libforms(), "fl_add_xyplot_overlay_file", 17244 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int, STRING, FL_COLOR], 17245 """int fl_add_xyplot_overlay_file(FL_OBJECT * ob, int id, 17246 const char * f, FL_COLOR c) 17247 """) 17248 iidnum = convert_to_int(idnum) 17249 sf = convert_to_string(f) 17250 ulcolr = convert_to_FL_COLOR(colr) 17251 keep_elem_refs(pObject, idnum, f, colr, iidnum, sf, ulcolr) 17252 retval = _fl_add_xyplot_overlay_file(pObject, iidnum, sf, ulcolr) 17253 return retval
17254 17255
17256 -def fl_set_xyplot_return(pObject, when):
17257 """ fl_set_xyplot_return(pObject, when) 17258 17259 @param pObject : pointer to object 17260 """ 17261 17262 _fl_set_xyplot_return = cfuncproto( 17263 load_so_libforms(), "fl_set_xyplot_return", 17264 None, [cty.POINTER(FL_OBJECT), cty.c_int], 17265 """void fl_set_xyplot_return(FL_OBJECT * ob, int when) 17266 """) 17267 iwhen = convert_to_int(when) 17268 keep_elem_refs(pObject, when, iwhen) 17269 _fl_set_xyplot_return(pObject, iwhen)
17270 17271
17272 -def fl_set_xyplot_xtics(pObject, major, minor):
17273 """ fl_set_xyplot_xtics(pObject, major, minor) 17274 17275 @param pObject : pointer to object 17276 """ 17277 17278 _fl_set_xyplot_xtics = cfuncproto( 17279 load_so_libforms(), "fl_set_xyplot_xtics", 17280 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 17281 """void fl_set_xyplot_xtics(FL_OBJECT * ob, int major, int minor) 17282 """) 17283 imajor = convert_to_int(major) 17284 iminor = convert_to_int(minor) 17285 keep_elem_refs(pObject, major, minor, imajor, iminor) 17286 _fl_set_xyplot_xtics(pObject, imajor, iminor)
17287 17288
17289 -def fl_set_xyplot_ytics(pObject, major, minor):
17290 """ fl_set_xyplot_ytics(pObject, major, minor) 17291 17292 @param pObject : pointer to object 17293 """ 17294 17295 _fl_set_xyplot_ytics = cfuncproto( 17296 load_so_libforms(), "fl_set_xyplot_ytics", 17297 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 17298 """void fl_set_xyplot_ytics(FL_OBJECT * ob, int major, int minor) 17299 """) 17300 imajor = convert_to_int(major) 17301 iminor = convert_to_int(minor) 17302 keep_elem_refs(pObject, major, minor, imajor, iminor) 17303 _fl_set_xyplot_ytics(pObject, imajor, iminor)
17304 17305
17306 -def fl_set_xyplot_xbounds(pObject, minbound, maxbound):
17307 """ fl_set_xyplot_xbounds(pObject, minbound, maxbound) 17308 17309 @param pObject : pointer to object 17310 """ 17311 17312 _fl_set_xyplot_xbounds = cfuncproto( 17313 load_so_libforms(), "fl_set_xyplot_xbounds", 17314 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 17315 """void fl_set_xyplot_xbounds(FL_OBJECT * ob, double xmin, 17316 double xmax) 17317 """) 17318 fminbound = convert_to_double(minbound) 17319 fmaxbound = convert_to_double(maxbound) 17320 keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 17321 _fl_set_xyplot_xbounds(pObject, fminbound, fmaxbound)
17322 17323
17324 -def fl_set_xyplot_ybounds(pObject, minbound, maxbound):
17325 """ fl_set_xyplot_ybounds(pObject, minbound, maxbound) 17326 17327 @param pObject : pointer to object 17328 """ 17329 17330 _fl_set_xyplot_ybounds = cfuncproto( 17331 load_so_libforms(), "fl_set_xyplot_ybounds", 17332 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double], 17333 """void fl_set_xyplot_ybounds(FL_OBJECT * ob, double ymin, 17334 double ymax) 17335 """) 17336 fminbound = convert_to_double(minbound) 17337 fmaxbound = convert_to_double(maxbound) 17338 keep_elem_refs(pObject, minbound, maxbound, fminbound, fmaxbound) 17339 _fl_set_xyplot_ybounds(pObject, fminbound, fmaxbound)
17340 17341 17342 #def fl_get_xyplot_xbounds(pObject, minbound, maxbound) *API change*
17343 -def fl_get_xyplot_xbounds(pObject):
17344 """ fl_get_xyplot_xbounds(pObject) -> minbound, maxbound 17345 17346 @param pObject : pointer to object 17347 """ 17348 17349 _fl_get_xyplot_xbounds = cfuncproto( 17350 load_so_libforms(), "fl_get_xyplot_xbounds", 17351 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 17352 cty.POINTER(cty.c_float)], 17353 """void fl_get_xyplot_xbounds(FL_OBJECT * ob, float * xmin, 17354 float * xmax) 17355 """) 17356 minbound, pminbound = make_float_and_pointer() 17357 maxbound, pmaxbound = make_float_and_pointer() 17358 keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 17359 _fl_get_xyplot_xbounds(pObject, pminbound, pmaxbound) 17360 return minbound, maxbound
17361 17362 17363 #def fl_get_xyplot_ybounds(pObject, minbound, maxbound) *API change*
17364 -def fl_get_xyplot_ybounds(pObject):
17365 """ fl_get_xyplot_ybounds(pObject) -> minbound, maxbound 17366 17367 @param pObject : pointer to object 17368 """ 17369 17370 _fl_get_xyplot_ybounds = cfuncproto( 17371 load_so_libforms(), "fl_get_xyplot_ybounds", 17372 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 17373 cty.POINTER(cty.c_float)], 17374 """void fl_get_xyplot_ybounds(FL_OBJECT * ob, float * ymin, 17375 float * ymax) 17376 """) 17377 minbound, pminbound = make_float_and_pointer() 17378 maxbound, pmaxbound = make_float_and_pointer() 17379 keep_elem_refs(pObject, minbound, maxbound, pminbound, pmaxbound) 17380 _fl_get_xyplot_ybounds(pObject, pminbound, pmaxbound) 17381 return minbound, maxbound
17382 17383 17384 #def fl_get_xyplot(pObject, x, y, i) *API change*
17385 -def fl_get_xyplot(pObject):
17386 """ 17387 fl_get_xyplot(pObject) -> x, y, i 17388 17389 @param pObject : pointer to object 17390 """ 17391 17392 _fl_get_xyplot = cfuncproto( 17393 load_so_libforms(), "fl_get_xyplot", 17394 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 17395 cty.POINTER(cty.c_float), cty.POINTER(cty.c_int)], 17396 """void fl_get_xyplot(FL_OBJECT * ob, float * x, float * y, 17397 int * i) 17398 """) 17399 x, px = make_float_and_pointer() 17400 y, py = make_float_and_pointer() 17401 i, pi = make_int_and_pointer() 17402 keep_elem_refs(pObject, x, y, i, px, py, pi) 17403 _fl_get_xyplot(pObject, px, py, pi) 17404 return x, y, i
17405 17406 17407 #def fl_get_xyplot_data(pObject, x, y, n) *API change*
17408 -def fl_get_xyplot_data(pObject):
17409 """ fl_get_xyplot_data(pObject) -> x, y, n 17410 17411 @param pObject : pointer to object 17412 """ 17413 17414 _fl_get_xyplot_data = cfuncproto( 17415 load_so_libforms(), "fl_get_xyplot_data", 17416 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 17417 cty.POINTER(cty.c_float), cty.POINTER(cty.c_int)], 17418 """void fl_get_xyplot_data(FL_OBJECT * ob, float * x, float * y, 17419 int * n) 17420 """) 17421 x, px = make_float_and_pointer() 17422 y, py = make_float_and_pointer() 17423 n, pn = make_int_and_pointer() 17424 keep_elem_refs(pObject, x, y, n, px, py, pn) 17425 _fl_get_xyplot_data(pObject, px, py, pn) 17426 return x, y, n
17427 17428 17429 #def fl_get_xyplot_data_pointer(pObject, idnum, x, y, n) *API change*
17430 -def fl_get_xyplot_data_pointer(pObject, idnum):
17431 """ fl_get_xyplot_data_pointer(pObject, idnum) -> x, y, n 17432 17433 @param pObject : pointer to object 17434 """ 17435 17436 _fl_get_xyplot_data_pointer = cfuncproto( 17437 load_so_libforms(), "fl_get_xyplot_data_pointer", 17438 None, [cty.POINTER(FL_OBJECT), cty.c_int, 17439 cty.POINTER(cty.POINTER(cty.c_float)), 17440 cty.POINTER(cty.POINTER(cty.c_float)), cty.POINTER(cty.c_int)], 17441 """void fl_get_xyplot_data_cty.POINTER(FL_OBJECT * ob, int id, 17442 float * * x, float * * y, int * n) 17443 """) 17444 iidnum = convert_to_int(idnum) 17445 x, px = make_float_and_pointer() 17446 y, py = make_float_and_pointer() 17447 n, pn = make_int_and_pointer() 17448 keep_elem_refs(pObject, idnum, iidnum, x, y, n, px, py, pn) 17449 _fl_get_xyplot_data_pointer(pObject, iidnum, px, py, pn) 17450 return x, y, n
17451 17452 17453 #def fl_get_xyplot_overlay_data(pObject, idnum, x, y, n) *API change*
17454 -def fl_get_xyplot_overlay_data(pObject, idnum):
17455 """ fl_get_xyplot_overlay_data(pObject, idnum) -> x, y, n 17456 17457 @param pObject : pointer to object 17458 """ 17459 17460 _fl_get_xyplot_overlay_data = cfuncproto( 17461 load_so_libforms(), "fl_get_xyplot_overlay_data", 17462 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.POINTER(cty.c_float), 17463 cty.POINTER(cty.c_float), cty.POINTER(cty.c_int)], 17464 """void fl_get_xyplot_overlay_data(FL_OBJECT * ob, int id, 17465 float * x, float * y, int * n) 17466 """) 17467 iidnum = convert_to_int(idnum) 17468 x, px = make_float_and_pointer() 17469 y, py = make_float_and_pointer() 17470 n, pn = make_int_and_pointer() 17471 keep_elem_refs(pObject, idnum, iidnum, x, y, n, px, py, pn) 17472 _fl_get_xyplot_overlay_data(pObject, iidnum, px, py, pn) 17473 return x, y, n
17474 17475
17476 -def fl_set_xyplot_overlay_type(pObject, idnum, plottype):
17477 """ fl_set_xyplot_overlay_type(pObject, idnum, plottype) 17478 17479 @param pObject : pointer to object 17480 """ 17481 17482 _fl_set_xyplot_overlay_type = cfuncproto( 17483 load_so_libforms(), "fl_set_xyplot_overlay_type", 17484 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 17485 """void fl_set_xyplot_overlay_type(FL_OBJECT * ob, int id, 17486 int type) 17487 """) 17488 iidnum = convert_to_int(idnum) 17489 iplottype = convert_to_int(plottype) 17490 keep_elem_refs(pObject, idnum, plottype, iidnum, iplottype) 17491 _fl_set_xyplot_overlay_type(pObject, iidnum, iplottype)
17492 17493
17494 -def fl_delete_xyplot_overlay(pObject, idnum):
17495 """ fl_delete_xyplot_overlay(pObject, idnum) 17496 17497 @param pObject : pointer to object 17498 """ 17499 17500 _fl_delete_xyplot_overlay = cfuncproto( 17501 load_so_libforms(), "fl_delete_xyplot_overlay", 17502 None, [cty.POINTER(FL_OBJECT), cty.c_int], 17503 """void fl_delete_xyplot_overlay(FL_OBJECT * ob, int id) 17504 """) 17505 iidnum = convert_to_int(idnum) 17506 keep_elem_refs(pObject, idnum, iidnum) 17507 _fl_delete_xyplot_overlay(pObject, iidnum)
17508 17509
17510 -def fl_set_xyplot_interpolate(pObject, idnum, deg, grid):
17511 """ 17512 fl_set_xyplot_interpolate(pObject, idnum, deg, grid) 17513 17514 @param pObject : pointer to object 17515 """ 17516 17517 _fl_set_xyplot_interpolate = cfuncproto( 17518 load_so_libforms(), "fl_set_xyplot_interpolate", 17519 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int, 17520 cty.c_double], 17521 """void fl_set_xyplot_interpolate(FL_OBJECT * ob, int id, 17522 int deg, double grid) 17523 """) 17524 iidnum = convert_to_int(idnum) 17525 ideg = convert_to_int(deg) 17526 fgrid = convert_to_double(grid) 17527 keep_elem_refs(pObject, idnum, deg, grid, iidnum, ideg, fgrid) 17528 _fl_set_xyplot_interpolate(pObject, iidnum, ideg, fgrid)
17529 17530
17531 -def fl_set_xyplot_inspect(pObject, yes):
17532 """ 17533 fl_set_xyplot_inspect(pObject, yes) 17534 17535 @param pObject : pointer to object 17536 """ 17537 17538 _fl_set_xyplot_inspect = cfuncproto( 17539 load_so_libforms(), "fl_set_xyplot_inspect", 17540 None, [cty.POINTER(FL_OBJECT), cty.c_int], 17541 """void fl_set_xyplot_inspect(FL_OBJECT * ob, int yes) 17542 """) 17543 iyes = convert_to_int(yes) 17544 keep_elem_refs(pObject, yes, iyes) 17545 _fl_set_xyplot_inspect(pObject, iyes)
17546 17547
17548 -def fl_set_xyplot_symbolsize(pObject, n):
17549 """ 17550 fl_set_xyplot_symbolsize(pObject, n) 17551 17552 @param pObject : pointer to object 17553 """ 17554 17555 _fl_set_xyplot_symbolsize = cfuncproto( 17556 load_so_libforms(), "fl_set_xyplot_symbolsize", 17557 None, [cty.POINTER(FL_OBJECT), cty.c_int], 17558 """void fl_set_xyplot_symbolsize(FL_OBJECT * ob, int n) 17559 """) 17560 inum = convert_to_int(n) 17561 keep_elem_refs(pObject, n, inum) 17562 _fl_set_xyplot_symbolsize(pObject, inum)
17563 17564
17565 -def fl_replace_xyplot_point(pObject, i, valx, valy):
17566 """ 17567 fl_replace_xyplot_point(pObject, i, valx, valy) 17568 17569 @param pObject : pointer to object 17570 """ 17571 17572 _fl_replace_xyplot_point = cfuncproto( 17573 load_so_libforms(), "fl_replace_xyplot_point", 17574 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_double, 17575 cty.c_double], 17576 """void fl_replace_xyplot_point(FL_OBJECT * ob, int i, 17577 double x, double y) 17578 """) 17579 ii = convert_to_int(i) 17580 fvalx = convert_to_double(valx) 17581 fvaly = convert_to_double(valy) 17582 keep_elem_refs(pObject, i, valx, valy, ii, fvalx, fvaly) 17583 _fl_replace_xyplot_point(pObject, ii, fvalx, fvaly)
17584 17585 17586 # Replace the value of a particular point in dataset setID, 17587 # where setID=0 is the first data set. 17588 # This routine is an extension of fl_replace_xyplot_point 17589 # which acts on the first dataset only. 17590
17591 -def fl_replace_xyplot_point_in_overlay(pObject, i, setID, valx, valy):
17592 """ 17593 fl_replace_xyplot_point_in_overlay(pObject, i, setID, valx, valy) 17594 17595 @param pObject : pointer to object 17596 """ 17597 17598 _fl_replace_xyplot_point_in_overlay = cfuncproto( 17599 load_so_libforms(), "fl_replace_xyplot_point_in_overlay", 17600 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int, \ 17601 cty.c_double, cty.c_double], 17602 """void fl_replace_xyplot_point_in_overlay(FL_OBJECT * ob, 17603 int i, int setID, double x, double y) 17604 """) 17605 ii = convert_to_int(i) 17606 isetID = convert_to_int(setID) 17607 fvalx = convert_to_double(valx) 17608 fvaly = convert_to_double(valy) 17609 keep_elem_refs(pObject, i, setID, valx, valy, ii, isetID, fvalx, fvaly) 17610 _fl_replace_xyplot_point_in_overlay(pObject, ii, isetID, fvalx, fvaly)
17611 17612 17613 #def fl_get_xyplot_xmapping(pObject, a, b) *API change*
17614 -def fl_get_xyplot_xmapping(pObject):
17615 """ 17616 fl_get_xyplot_xmapping(pObject) -> a, b 17617 17618 @param pObject : pointer to object 17619 """ 17620 17621 _fl_get_xyplot_xmapping = cfuncproto( 17622 load_so_libforms(), "fl_get_xyplot_xmapping", 17623 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 17624 cty.POINTER(cty.c_float)], 17625 """void fl_get_xyplot_xmapping(FL_OBJECT * ob, float * a, 17626 float * b) 17627 """) 17628 a, pa = make_float_and_pointer() 17629 b, pb = make_float_and_pointer() 17630 keep_elem_refs(pObject, a, b, pa, pb) 17631 _fl_get_xyplot_xmapping(pObject, pa, pb) 17632 return a, b
17633 17634 17635 #def fl_get_xyplot_ymapping(pObject, a, b) *API change*
17636 -def fl_get_xyplot_ymapping(pObject):
17637 """ 17638 fl_get_xyplot_ymapping(pObject) -> a, b 17639 17640 @param pObject : pointer to object 17641 """ 17642 17643 _fl_get_xyplot_ymapping = cfuncproto( 17644 load_so_libforms(), "fl_get_xyplot_ymapping", 17645 None, [cty.POINTER(FL_OBJECT), cty.POINTER(cty.c_float), 17646 cty.POINTER(cty.c_float)], 17647 """void fl_get_xyplot_ymapping(FL_OBJECT * ob, float * a, 17648 float * b) 17649 """) 17650 a, pa = make_float_and_pointer() 17651 b, pb = make_float_and_pointer() 17652 keep_elem_refs(pObject, a, b, pa, pb) 17653 _fl_get_xyplot_ymapping(pObject, pa, pb) 17654 return a, b
17655 17656
17657 -def fl_set_xyplot_keys(pObject, keys, valx, valy, align):
17658 """ 17659 fl_set_xyplot_keys(pObject, keys, valx, valy, align) 17660 17661 @param pObject : pointer to object 17662 """ 17663 17664 _fl_set_xyplot_keys = cfuncproto( 17665 load_so_libforms(), "fl_set_xyplot_keys", 17666 None, [cty.POINTER(FL_OBJECT), cty.POINTER(STRING), cty.c_float, 17667 cty.c_float, cty.c_int], 17668 """void fl_set_xyplot_keys(FL_OBJECT * ob, char * * keys, float x, 17669 float y, int align) 17670 """) 17671 fvalx = convert_to_float(valx) 17672 fvaly = convert_to_float(valy) 17673 ialign = convert_to_int(align) 17674 keep_elem_refs(pObject, keys, valx, valy, align, fvalx, fvaly, ialign) 17675 _fl_set_xyplot_keys(pObject, keys, fvalx, fvaly, ialign)
17676 17677
17678 -def fl_set_xyplot_key(pObject, idnum, keytxt):
17679 """ 17680 fl_set_xyplot_key(pObject, idnum, keytxt) 17681 17682 @param pObject : pointer to object 17683 """ 17684 17685 _fl_set_xyplot_key = cfuncproto( 17686 load_so_libforms(), "fl_set_xyplot_key", 17687 None, [cty.POINTER(FL_OBJECT), cty.c_int, STRING], 17688 """void fl_set_xyplot_key(FL_OBJECT * ob, int id, 17689 const char * key) 17690 """) 17691 iidnum = convert_to_int(idnum) 17692 skeytxt = convert_to_string(keytxt) 17693 keep_elem_refs(pObject, idnum, keytxt, iidnum, skeytxt) 17694 _fl_set_xyplot_key(pObject, iidnum, skeytxt)
17695 17696
17697 -def fl_set_xyplot_key_position(pObject, valx, valy, align):
17698 """ 17699 fl_set_xyplot_key_position(pObject, valx, valy, align) 17700 17701 @param pObject : pointer to object 17702 """ 17703 17704 _fl_set_xyplot_key_position = cfuncproto( 17705 load_so_libforms(), "fl_set_xyplot_key_position", 17706 None, [cty.POINTER(FL_OBJECT), cty.c_float, cty.c_float, 17707 cty.c_int], 17708 """void fl_set_xyplot_key_position(FL_OBJECT * ob, float x, 17709 float y, int align) 17710 """) 17711 fvalx = convert_to_float(valx) 17712 fvaly = convert_to_float(valy) 17713 ialign = convert_to_int(align) 17714 keep_elem_refs(pObject, valx, valy, align, fvalx, fvaly, ialign) 17715 _fl_set_xyplot_key_position(pObject, fvalx, fvaly, ialign)
17716 17717
17718 -def fl_set_xyplot_key_font(pObject, style, size):
17719 """ 17720 fl_set_xyplot_key_font(pObject, style, size) 17721 17722 @param pObject : pointer to object 17723 """ 17724 17725 _fl_set_xyplot_key_font = cfuncproto( 17726 load_so_libforms(), "fl_set_xyplot_key_font", 17727 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 17728 """void fl_set_xyplot_key_font(FL_OBJECT * ob, int style, 17729 int size) 17730 """) 17731 istyle = convert_to_int(style) 17732 isize = convert_to_int(size) 17733 keep_elem_refs(pObject, style, size, istyle, isize) 17734 _fl_set_xyplot_key_font(pObject, istyle, isize)
17735 17736
17737 -def fl_get_xyplot_numdata(pObject, idnum):
17738 """ 17739 fl_get_xyplot_numdata(pObject, idnum) -> num. 17740 17741 @param pObject : pointer to object 17742 """ 17743 17744 _fl_get_xyplot_numdata = cfuncproto( 17745 load_so_libforms(), "fl_get_xyplot_numdata", 17746 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 17747 """int fl_get_xyplot_numdata(FL_OBJECT * ob, int id) 17748 """) 17749 iidnum = convert_to_int(idnum) 17750 keep_elem_refs(pObject, idnum, iidnum) 17751 retval = _fl_get_xyplot_numdata(pObject, iidnum) 17752 return retval
17753 17754 17755 # The following two functions will be removed. 17756 # Use fl_set_object_l[size|style] for the functionalities 17757
17758 -def fl_set_xyplot_fontsize(pObject, size):
17759 """ 17760 fl_set_xyplot_fontsize(pObject, size) 17761 17762 @param pObject : pointer to object 17763 """ 17764 17765 _fl_set_xyplot_fontsize = cfuncproto( 17766 load_so_libforms(), "fl_set_xyplot_fontsize", 17767 None, [cty.POINTER(FL_OBJECT), cty.c_int], 17768 """void fl_set_xyplot_fontsize(FL_OBJECT * ob, int size) DEPRECATED 17769 """) 17770 warn_deprecated_function("Use fl_set_lsize, instead.") 17771 isize = convert_to_int(size) 17772 keep_elem_refs(pObject, size, isize) 17773 _fl_set_xyplot_fontsize(pObject, isize)
17774 17775
17776 -def fl_set_xyplot_fontstyle(pObject, style):
17777 """ 17778 fl_set_xyplot_fontstyle(pObject, style) 17779 17780 @param pObject : pointer to object 17781 """ 17782 17783 _fl_set_xyplot_fontstyle = cfuncproto( 17784 load_so_libforms(), "fl_set_xyplot_fontstyle", 17785 None, [cty.POINTER(FL_OBJECT), cty.c_int], 17786 """void fl_set_xyplot_fontstyle(FL_OBJECT * ob, int style) DEPRECATED 17787 """) 17788 warn_deprecated_function("Use fl_set_lstyle, instead.") 17789 istyle = convert_to_int(style) 17790 keep_elem_refs(pObject, style, istyle) 17791 _fl_set_xyplot_fontstyle(pObject, istyle)
17792 17793
17794 -def fl_xyplot_s2w(pObject, sx, sy, wx, wy):
17795 """ 17796 fl_xyplot_s2w(pObject, sx, sy, wx, wy) 17797 17798 @param pObject : pointer to object 17799 """ 17800 17801 _fl_xyplot_s2w = cfuncproto( 17802 load_so_libforms(), "fl_xyplot_s2w", 17803 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double, 17804 cty.POINTER(cty.c_float), cty.POINTER(cty.c_float)], 17805 """void fl_xyplot_s2w(FL_OBJECT * ob, double sx, double sy, 17806 float * wx, float * wy) 17807 """) 17808 fsx = convert_to_double(sx) 17809 fsy = convert_to_double(sy) 17810 keep_elem_refs(pObject, sx, sy, wx, wy, fsx, fsy) 17811 _fl_xyplot_s2w(pObject, fsx, fsy, wx, wy)
17812 17813
17814 -def fl_xyplot_w2s(pObject, wx, wy, sx, sy):
17815 """ 17816 fl_xyplot_w2s(pObject, wx, wy, sx, sy) 17817 17818 @param pObject : pointer to object 17819 """ 17820 17821 _fl_xyplot_w2s = cfuncproto( 17822 load_so_libforms(), "fl_xyplot_w2s", 17823 None, [cty.POINTER(FL_OBJECT), cty.c_double, cty.c_double, 17824 cty.POINTER(cty.c_float), cty.POINTER(cty.c_float)], 17825 """void fl_xyplot_w2s(FL_OBJECT * ob, double wx, double wy, 17826 float * sx, float * sy) 17827 """) 17828 fwx = convert_to_double(wx) 17829 fwy = convert_to_double(wy) 17830 keep_elem_refs(pObject, wx, wy, sx, sy, fwx, fwy) 17831 _fl_xyplot_w2s(pObject, fwx, fwy, sx, sy)
17832 17833
17834 -def fl_set_xyplot_xscale(pObject, scale, base):
17835 """ 17836 fl_set_xyplot_xscale(pObject, scale, base) 17837 17838 @param pObject : pointer to object 17839 """ 17840 17841 _fl_set_xyplot_xscale = cfuncproto( 17842 load_so_libforms(), "fl_set_xyplot_xscale", 17843 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_double], 17844 """void fl_set_xyplot_xscale(FL_OBJECT * ob, int scale, 17845 double base) 17846 """) 17847 iscale = convert_to_int(scale) 17848 fbase = convert_to_double(base) 17849 keep_elem_refs(pObject, scale, base, iscale, fbase) 17850 _fl_set_xyplot_xscale(pObject, iscale, fbase)
17851 17852
17853 -def fl_set_xyplot_yscale(pObject, scale, base):
17854 """ 17855 fl_set_xyplot_yscale(pObject, scale, base) 17856 17857 @param pObject : pointer to object 17858 """ 17859 17860 _fl_set_xyplot_yscale = cfuncproto( 17861 load_so_libforms(), "fl_set_xyplot_yscale", 17862 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_double], 17863 """void fl_set_xyplot_yscale(FL_OBJECT * ob, int scale, 17864 double base) 17865 """) 17866 iscale = convert_to_int(scale) 17867 fbase = convert_to_double(base) 17868 keep_elem_refs(pObject, scale, base, iscale, fbase) 17869 _fl_set_xyplot_yscale(pObject, iscale, fbase)
17870 17871
17872 -def fl_clear_xyplot(pObject):
17873 """ 17874 fl_clear_xyplot(pObject) 17875 17876 @param pObject : pointer to object 17877 """ 17878 17879 _fl_clear_xyplot = cfuncproto( 17880 load_so_libforms(), "fl_clear_xyplot", 17881 None, [cty.POINTER(FL_OBJECT)], 17882 """void fl_clear_xyplot(FL_OBJECT * ob) 17883 """) 17884 keep_elem_refs(pObject) 17885 _fl_clear_xyplot(pObject)
17886 17887
17888 -def fl_set_xyplot_linewidth(pObject, idnum, lw):
17889 """ 17890 fl_set_xyplot_linewidth(pObject, idnum, lw) 17891 17892 @param pObject : pointer to object 17893 """ 17894 17895 _fl_set_xyplot_linewidth = cfuncproto( 17896 load_so_libforms(), "fl_set_xyplot_linewidth", 17897 None, [cty.POINTER(FL_OBJECT), cty.c_int, cty.c_int], 17898 """void fl_set_xyplot_linewidth(FL_OBJECT * ob, int id, int lw) 17899 """) 17900 iidnum = convert_to_int(idnum) 17901 ilw = convert_to_int(lw) 17902 keep_elem_refs(pObject, idnum, lw, iidnum, ilw) 17903 _fl_set_xyplot_linewidth(pObject, iidnum, ilw)
17904 17905
17906 -def fl_set_xyplot_xgrid(pObject, xgrid):
17907 """ 17908 fl_set_xyplot_xgrid(pObject, xgrid) 17909 17910 @param pObject : pointer to object 17911 """ 17912 17913 _fl_set_xyplot_xgrid = cfuncproto( 17914 load_so_libforms(), "fl_set_xyplot_xgrid", 17915 None, [cty.POINTER(FL_OBJECT), cty.c_int], 17916 """void fl_set_xyplot_xgrid(FL_OBJECT * ob, int xgrid) 17917 """) 17918 ixgrid = convert_to_int(xgrid) 17919 keep_elem_refs(pObject, xgrid, ixgrid) 17920 _fl_set_xyplot_xgrid(pObject, ixgrid)
17921 17922
17923 -def fl_set_xyplot_ygrid(pObject, ygrid):
17924 """ 17925 fl_set_xyplot_ygrid(pObject, ygrid) 17926 17927 @param pObject : pointer to object 17928 """ 17929 17930 _fl_set_xyplot_ygrid = cfuncproto( 17931 load_so_libforms(), "fl_set_xyplot_ygrid", 17932 None, [cty.POINTER(FL_OBJECT), cty.c_int], 17933 """void fl_set_xyplot_ygrid(FL_OBJECT * ob, int ygrid) 17934 """) 17935 iygrid = convert_to_int(ygrid) 17936 keep_elem_refs(pObject, ygrid, iygrid) 17937 _fl_set_xyplot_ygrid(pObject, iygrid)
17938 17939
17940 -def fl_set_xyplot_grid_linestyle(pObject, style):
17941 """ 17942 fl_set_xyplot_grid_linestyle(pObject, style) -> num. 17943 17944 @param pObject : pointer to object 17945 """ 17946 17947 _fl_set_xyplot_grid_linestyle = cfuncproto( 17948 load_so_libforms(), "fl_set_xyplot_grid_linestyle", 17949 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 17950 """int fl_set_xyplot_grid_linestyle(FL_OBJECT * ob, int style) 17951 """) 17952 istyle = convert_to_int(style) 17953 keep_elem_refs(pObject, style, istyle) 17954 retval = _fl_set_xyplot_grid_linestyle(pObject, istyle) 17955 return retval
17956 17957
17958 -def fl_set_xyplot_alphaxtics(pObject, m, s):
17959 """ 17960 fl_set_xyplot_alphaxtics(pObject, m, s) 17961 17962 @param pObject : pointer to object 17963 """ 17964 17965 _fl_set_xyplot_alphaxtics = cfuncproto( 17966 load_so_libforms(), "fl_set_xyplot_alphaxtics", 17967 None, [cty.POINTER(FL_OBJECT), STRING, STRING], 17968 """void fl_set_xyplot_alphaxtics(FL_OBJECT * ob, const char * m, 17969 const char * s) 17970 """) 17971 sm = convert_to_string(m) 17972 ss = convert_to_string(s) 17973 keep_elem_refs(pObject, m, s, sm, ss) 17974 _fl_set_xyplot_alphaxtics(pObject, sm, ss)
17975 17976
17977 -def fl_set_xyplot_alphaytics(pObject, m, s):
17978 """ 17979 fl_set_xyplot_alphaytics(pObject, m, s) 17980 17981 @param pObject : pointer to object 17982 """ 17983 17984 _fl_set_xyplot_alphaytics = cfuncproto( 17985 load_so_libforms(), "fl_set_xyplot_alphaytics", 17986 None, [cty.POINTER(FL_OBJECT), STRING, STRING], 17987 """void fl_set_xyplot_alphaytics(FL_OBJECT * ob, const char * m, 17988 const char * s) 17989 """) 17990 sm = convert_to_string(m) 17991 ss = convert_to_string(s) 17992 keep_elem_refs(pObject, m, s, sm, ss) 17993 _fl_set_xyplot_alphaytics(pObject, sm, ss)
17994 17995
17996 -def fl_set_xyplot_fixed_xaxis(pObject, lm, rm):
17997 """ 17998 fl_set_xyplot_fixed_xaxis(pObject, lm, rm) 17999 18000 @param pObject : pointer to object 18001 """ 18002 18003 _fl_set_xyplot_fixed_xaxis = cfuncproto( 18004 load_so_libforms(), "fl_set_xyplot_fixed_xaxis", 18005 None, [cty.POINTER(FL_OBJECT), STRING, STRING], 18006 """void fl_set_xyplot_fixed_xaxis(FL_OBJECT * ob, const char * lm, 18007 const char * rm) 18008 """) 18009 slm = convert_to_string(lm) 18010 srm = convert_to_string(rm) 18011 keep_elem_refs(pObject, lm, rm, slm, srm) 18012 _fl_set_xyplot_fixed_xaxis(pObject, slm, srm)
18013 18014
18015 -def fl_set_xyplot_fixed_yaxis(pObject, bm, tm):
18016 """ 18017 fl_set_xyplot_fixed_yaxis(pObject, bm, tm) 18018 18019 @param pObject : pointer to object 18020 """ 18021 18022 _fl_set_xyplot_fixed_yaxis = cfuncproto( 18023 load_so_libforms(), "fl_set_xyplot_fixed_yaxis", 18024 None, [cty.POINTER(FL_OBJECT), STRING, STRING], 18025 """void fl_set_xyplot_fixed_yaxis(FL_OBJECT * ob, const char * bm, 18026 const char * tm) 18027 """) 18028 sbm = convert_to_string(bm) 18029 stm = convert_to_string(tm) 18030 keep_elem_refs(pObject, bm, tm, sbm, stm) 18031 _fl_set_xyplot_fixed_yaxis(pObject, sbm, stm)
18032 18033
18034 -def fl_interpolate(wx, wy, nin, x, y, grid, ndeg):
18035 """ fl_interpolate(wx, wy, nin, x, y, grid, ndeg) -> num. 18036 """ 18037 18038 _fl_interpolate = cfuncproto( 18039 load_so_libforms(), "fl_interpolate", 18040 cty.c_int, [cty.POINTER(cty.c_float), cty.POINTER(cty.c_float), 18041 cty.c_int, cty.POINTER(cty.c_float), cty.POINTER(cty.c_float), 18042 cty.c_double, cty.c_int], 18043 """int fl_interpolate(const char * wx, const char * wy, int nin, 18044 float * x, float * y, double grid, int ndeg) 18045 """) 18046 inin = convert_to_int(nin) 18047 fgrid = convert_to_double(grid) 18048 indeg = convert_to_int(ndeg) 18049 keep_elem_refs(wx, wy, nin, x, y, grid, ndeg, inin, fgrid, indeg) 18050 retval = _fl_interpolate(wx, wy, inin, x, y, fgrid, indeg) 18051 return retval
18052 18053
18054 -def fl_spline_interpolate(wx, wy, nin, x, y, grid):
18055 """ fl_spline_interpolate(wx, wy, nin, x, y, grid) -> num. 18056 """ 18057 18058 _fl_spline_interpolate = cfuncproto( 18059 load_so_libforms(), "fl_spline_interpolate", 18060 cty.c_int, [cty.POINTER(cty.c_float), cty.POINTER(cty.c_float), 18061 cty.c_int, cty.POINTER(cty.c_float), cty.POINTER(cty.c_float), 18062 cty.c_double], 18063 """int fl_spline_interpolate(const char * wx, const char * wy, 18064 int nin, float * x, float * y, double grid) 18065 """) 18066 inin = convert_to_int(nin) 18067 fgrid = convert_to_double(grid) 18068 keep_elem_refs(wx, wy, nin, x, y, grid, inin, fgrid) 18069 retval = _fl_spline_interpolate(wx, wy, inin, x, y, fgrid) 18070 return retval
18071 18072 18073 FL_XYPLOT_SYMBOL = cty.CFUNCTYPE(None, cty.POINTER(FL_OBJECT), cty.c_int, 18074 cty.POINTER(FL_POINT), cty.c_int, cty.c_int, cty.c_int) 18075
18076 -def fl_set_xyplot_symbol(pObject, idnum, py_XyPlotSymbol):
18077 """ 18078 fl_set_xyplot_symbol(pObject, idnum, py_XyPlotSymbol) -> xyplot_symbol func. 18079 18080 @param pObject : pointer to object 18081 """ 18082 18083 _fl_set_xyplot_symbol = cfuncproto( 18084 load_so_libforms(), "fl_set_xyplot_symbol", 18085 FL_XYPLOT_SYMBOL, [cty.POINTER(FL_OBJECT), cty.c_int, 18086 FL_XYPLOT_SYMBOL], 18087 """FL_XYPLOT_SYMBOL fl_set_xyplot_symbol(FL_OBJECT * ob, int id, 18088 FL_XYPLOT_SYMBOL symbol) 18089 """) 18090 iidnum = convert_to_int(idnum) 18091 c_XyPlotSymbol = FL_XYPLOT_SYMBOL(py_XyPlotSymbol) 18092 keep_cfunc_refs(c_XyPlotSymbol, py_XyPlotSymbol) 18093 keep_elem_refs(pObject, idnum, iidnum) 18094 retval = _fl_set_xyplot_symbol(pObject, iidnum, c_XyPlotSymbol) 18095 return retval
18096 18097
18098 -def fl_set_xyplot_mark_active(pObject, y):
18099 """ 18100 fl_set_xyplot_mark_active(pObject, y) -> num. 18101 18102 @param pObject : pointer to object 18103 """ 18104 18105 _fl_set_xyplot_mark_active = cfuncproto( 18106 load_so_libforms(), "fl_set_xyplot_mark_active", 18107 cty.c_int, [cty.POINTER(FL_OBJECT), cty.c_int], 18108 """int fl_set_xyplot_mark_active(FL_OBJECT * ob, int y) 18109 """) 18110 iy = convert_to_int(y) 18111 keep_elem_refs(pObject, y, iy) 18112 retval = _fl_set_xyplot_mark_active(pObject, iy) 18113 return retval
18114 18115 18116 # the following (fl_fheight) etc. were never documented and were 18117 # removed from V0.89, but apparently this broke some applications that 18118 # were using them. Put them back in 10/22/00 18119
18120 -def fl_gc_():
18121 """ fl_gc_() -> gc 18122 """ 18123 18124 _fl_gc_ = cfuncproto( 18125 load_so_libforms(), "fl_gc_", 18126 GC, [], 18127 """GC fl_gc_() 18128 """) 18129 retval = _fl_gc_() 18130 return retval
18131 18132
18133 -def fl_textgc_():
18134 """ fl_textgc_() -> gc 18135 """ 18136 18137 _fl_textgc_ = cfuncproto( 18138 load_so_libforms(), "fl_textgc_", 18139 GC, [], 18140 """)GC fl_textgc_() 18141 """) 18142 retval = _fl_textgc_() 18143 return retval
18144 18145
18146 -def fl_fheight_():
18147 """ fl_fheight_() -> num. 18148 """ 18149 18150 _fl_fheight_ = cfuncproto( 18151 load_so_libforms(), "fl_fheight_", 18152 cty.c_int, [], 18153 """int fl_fheight_() 18154 """) 18155 retval = _fl_fheight_() 18156 return retval
18157 18158
18159 -def fl_fdesc_():
18160 """ fl_fdesc_() -> num. 18161 """ 18162 18163 _fl_fdesc_ = cfuncproto( 18164 load_so_libforms(), "fl_fdesc_", 18165 cty.c_int, [], 18166 """int fl_fdesc_() 18167 """) 18168 retval = _fl_fdesc_() 18169 return retval
18170 18171
18172 -def fl_cur_win_():
18173 """ fl_cur_win_() -> window 18174 """ 18175 18176 _fl_cur_win_ = cfuncproto( 18177 load_so_libforms(), "fl_cur_win_", 18178 Window, [], 18179 """Window fl_cur_win_() 18180 """) 18181 retval = _fl_cur_win_() 18182 return retval
18183 18184
18185 -def fl_cur_fs_():
18186 """ fl_cur_fs_() -> XFontStruct class 18187 """ 18188 18189 _fl_cur_fs_ = cfuncproto( 18190 load_so_libforms(), "fl_cur_fs_", 18191 cty.POINTER(XFontStruct), [], 18192 """XFontStruct * fl_cur_fs_() 18193 """) 18194 retval = _fl_cur_fs_() 18195 return retval
18196 18197 18198 # commented to prevent a SegmentationFault during installation --LK 18199 #fl_textgc = fl_textgc_() 18200 fl_textgc = fl_textgc_ 18201 #fl_gc = fl_gc_() 18202 fl_gc = fl_gc_ 18203 #fl_cur_win = fl_cur_win_() 18204 fl_cur_win = fl_cur_win_ 18205 #fl_fheight = fl_fheight_() 18206 fl_fheight = fl_fheight_ 18207 #fl_fdesc = fl_fdesc_() 18208 fl_fdesc = fl_fdesc_ 18209 #fl_cur_fs = fl_cur_fs_() 18210 fl_cur_fs = fl_cur_fs_ 18211 18212
18213 -def fl_display_():
18214 """ fl_display_() -> pDisplay 18215 """ 18216 18217 _fl_display_ = cfuncproto( 18218 load_so_libforms(), "fl_display_", 18219 cty.POINTER(Display), [], 18220 """Display * fl_display_() 18221 """) 18222 retval = _fl_display_() 18223 return retval
18224 18225 18226 18227 ######################### 18228 # flimage.h 18229 # Image related routines 18230 ######################### 18231 18232 # low-level, maybe unused in python --LK 18233 #def fl_safe_free(p): 18234 # if p: 18235 # fl_free(p) 18236 # p = None # UNSURE 18237
18238 -def FL_RGB2GRAY(r, g, b):
18239 return cty.c_uint((78 * (r) + 150 * (g) + 28 * (b)) >> 8)
18240 18241 18242 # if PCBITS is not 8, we need to apply the RGBmask 18243
18244 -def FL_IsRGB(im):
18245 return (im.type == FL_IMAGE_RGB)
18246
18247 -def FL_IsPacked(im):
18248 return (im.type == FL_IMAGE_PACKED)
18249 18250
18251 -def flimage_setup(pImageSetup):
18252 """ flimage_setup(setup) 18253 """ 18254 18255 _flimage_setup = cfuncproto( 18256 load_so_libflimage(), "flimage_setup", 18257 None, [cty.POINTER(FLIMAGE_SETUP)], 18258 """void flimage_setup(FLIMAGE_SETUP * setup) 18259 """) 18260 keep_elem_refs(pImageSetup) 18261 _flimage_setup(pImageSetup)
18262 18263 18264 # basic IO routines 18265
18266 -def flimage_load(filename):
18267 """ flimage_load(filename) -> pImage 18268 """ 18269 18270 _flimage_load = cfuncproto( 18271 load_so_libflimage(), "flimage_load", 18272 cty.POINTER(FL_IMAGE), [STRING], 18273 """FL_IMAGE * flimage_load(const char * file) 18274 """) 18275 sfilename = convert_to_string(filename) 18276 keep_elem_refs(filename, sfilename) 18277 retval = _flimage_load(sfilename) 18278 return retval
18279 18280
18281 -def flimage_read(pImage):
18282 """ flimage_read(pImage) -> pImage 18283 """ 18284 18285 _flimage_read = cfuncproto( 18286 load_so_libflimage(), "flimage_read", 18287 cty.POINTER(FL_IMAGE), [cty.POINTER(FL_IMAGE)], 18288 """FL_IMAGE * flimage_read(FL_IMAGE * im) 18289 """) 18290 keep_elem_refs(pImage) 18291 retval = _flimage_read(pImage) 18292 return retval
18293 18294
18295 -def flimage_dump(pImage, p2, p3):
18296 """ flimage_dump(pImage, p2, p3) -> num. 18297 """ 18298 18299 _flimage_dump = cfuncproto( 18300 load_so_libflimage(), "flimage_dump", 18301 cty.c_int, [cty.POINTER(FL_IMAGE), STRING, STRING], 18302 """int flimage_dump(FL_IMAGE * p1, const char * p2, 18303 const char * p3) 18304 """) 18305 sp2 = convert_to_string(p2) 18306 sp3 = convert_to_string(p3) 18307 keep_elem_refs(pImage, p2, p3, sp2, sp3) 18308 retval = _flimage_dump(pImage, sp2, sp3) 18309 return retval
18310 18311
18312 -def flimage_close(pImage):
18313 """ flimage_close(pImage) -> num. 18314 """ 18315 18316 _flimage_close = cfuncproto( 18317 load_so_libflimage(), "flimage_close", 18318 cty.c_int, [cty.POINTER(FL_IMAGE)], 18319 """int flimage_close(FL_IMAGE * p1) 18320 """) 18321 keep_elem_refs(pImage) 18322 retval = _flimage_close(pImage) 18323 return retval
18324 18325
18326 -def flimage_alloc():
18327 """ flimage_alloc() -> pImage 18328 """ 18329 18330 _flimage_alloc = cfuncproto( 18331 load_so_libflimage(), "flimage_alloc", 18332 cty.POINTER(FL_IMAGE), [], 18333 """FL_IMAGE * flimage_alloc() 18334 """) 18335 retval = _flimage_alloc() 18336 return retval
18337 18338
18339 -def flimage_getmem(pImage):
18340 """ flimage_getmem(pImage) -> num. 18341 """ 18342 18343 _flimage_getmem = cfuncproto( 18344 load_so_libflimage(), "flimage_getmem", 18345 cty.c_int, [cty.POINTER(FL_IMAGE)], 18346 """int flimage_getmem(FL_IMAGE * p1) 18347 """) 18348 keep_elem_refs(pImage) 18349 retval = _flimage_getmem(pImage) 18350 return retval
18351 18352
18353 -def flimage_is_supported(p1):
18354 """ flimage_is_supported(p1) -> num. 18355 """ 18356 18357 _flimage_is_supported = cfuncproto( 18358 load_so_libflimage(), "flimage_is_supported", 18359 cty.c_int, [STRING], 18360 """int flimage_is_supported(const char * p1) 18361 """) 18362 sp1 = convert_to_string(p1) 18363 keep_elem_refs(p1, sp1) 18364 retval = _flimage_is_supported(sp1) 18365 return retval
18366 18367
18368 -def flimage_description_via_filter(pImage, p2, p3, p4):
18369 """ flimage_description_via_filter(pImage, p2, p3, p4) -> num. 18370 """ 18371 18372 _flimage_description_via_filter = cfuncproto( 18373 load_so_libflimage(), "flimage_description_via_filter", 18374 cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(STRING), STRING, 18375 cty.c_int], 18376 """int flimage_description_via_filter(FL_IMAGE * p1, 18377 const char * p2, const char * p3, int p4) 18378 """) 18379 sp3 = convert_to_string(p3) 18380 ip4 = convert_to_string(p4) 18381 keep_elem_refs(pImage, p2, p3, p4, sp3, ip4) 18382 retval = _flimage_description_via_filter(pImage, p2, sp3, ip4) 18383 return retval
18384 18385
18386 -def flimage_write_via_filter(pImage, p2, p3, p4):
18387 """ flimage_write_via_filter(pImage, p2, p3, p4) -> num. 18388 """ 18389 18390 _flimage_write_via_filter = cfuncproto( 18391 load_so_libflimage(), "flimage_write_via_filter", 18392 cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(STRING), 18393 cty.POINTER(STRING), cty.c_int], 18394 """int flimage_write_via_filter(FL_IMAGE * p1, const char * p2, 18395 const char * p3, int p4) 18396 """) 18397 ip4 = convert_to_int(p4) 18398 keep_elem_refs(pImage, p2, p3, p4, ip4) 18399 retval = _flimage_write_via_filter(pImage, p2, p3, ip4) 18400 return retval
18401 18402
18403 -def flimage_free(pImage):
18404 """ flimage_free(pImage) -> num. 18405 """ 18406 18407 _flimage_free = cfuncproto( 18408 load_so_libflimage(), "flimage_free", 18409 cty.c_int, [cty.POINTER(FL_IMAGE)], 18410 """int flimage_free(FL_IMAGE * p1) 18411 """) 18412 keep_elem_refs(pImage) 18413 retval = _flimage_free(pImage) 18414 return retval
18415 18416
18417 -def flimage_display(pImage, win):
18418 """ flimage_display(pImage, win) -> num. 18419 """ 18420 18421 _flimage_display = cfuncproto( 18422 load_so_libflimage(), "flimage_display", 18423 cty.c_int, [cty.POINTER(FL_IMAGE), Window], 18424 """int flimage_display(FL_IMAGE * p1, Window p2) 18425 """) 18426 ulwin = convert_to_Window(win) 18427 keep_elem_refs(pImage, win, ulwin) 18428 retval = _flimage_display(pImage, ulwin) 18429 return retval
18430 18431
18432 -def flimage_sdisplay(pImage, win):
18433 """ flimage_sdisplay(pImage, win) -> num. 18434 """ 18435 18436 _flimage_sdisplay = cfuncproto( 18437 load_so_libflimage(), "flimage_sdisplay", 18438 cty.c_int, [cty.POINTER(FL_IMAGE), Window], 18439 """int flimage_sdisplay(FL_IMAGE * p1, Window p2) 18440 """) 18441 ulwin = convert_to_Window(win) 18442 keep_elem_refs(pImage, win, ulwin) 18443 retval = _flimage_sdisplay(pImage, ulwin) 18444 return retval
18445 18446
18447 -def flimage_convert(pImage, p2, p3):
18448 """ flimage_convert(pImage, p2, p3) -> num. 18449 """ 18450 18451 _flimage_convert = cfuncproto( 18452 load_so_libflimage(), "flimage_convert", 18453 cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int], 18454 """int flimage_convert(FL_IMAGE * p1, int p2, int p3) 18455 """) 18456 ip2 = convert_to_int(p2) 18457 ip3 = convert_to_int(p3) 18458 keep_elem_refs(pImage, p2, p3, ip2, ip3) 18459 retval = _flimage_convert(pImage, ip2, ip3) 18460 return retval
18461 18462
18463 -def flimage_type_name(flimagetype):
18464 """ flimage_type_name(flimagetype) -> name string 18465 """ 18466 18467 _flimage_type_name = cfuncproto( 18468 load_so_libflimage(), "flimage_type_name", 18469 STRING, [cty.c_int], 18470 """const char * flimage_type_name(int type) 18471 """) 18472 iflimagetype = convert_to_int(flimagetype) 18473 keep_elem_refs(flimagetype, iflimagetype) 18474 retval = _flimage_type_name(iflimagetype) 18475 return retval
18476 18477
18478 -def flimage_add_text(pImage, text, p3, p4, p5, p6, p7, p8, p9, p10, p11):
18479 """ flimage_add_text(pImage, text, p3, p4, p5, p6, p7, p8, p9, p10, p11) -> num. 18480 """ 18481 18482 _flimage_add_text = cfuncproto( 18483 load_so_libflimage(), "flimage_add_text", 18484 cty.c_int, [cty.POINTER(FL_IMAGE), STRING, cty.c_int, cty.c_int, 18485 cty.c_int, cty.c_uint, cty.c_uint, cty.c_int, cty.c_double, 18486 cty.c_double, cty.c_int], 18487 """int flimage_add_text(FL_IMAGE * p1, const char * p2, int p3, 18488 int p4, int p5, unsigned int p6, unsigned int p7, int p8, 18489 double p9, double p10, int p11) 18490 """) 18491 stext = convert_to_string(text) 18492 ip3 = convert_to_int(p3) 18493 ip4 = convert_to_int(p4) 18494 ip5 = convert_to_int(p5) 18495 uip6 = convert_to_uint(p6) 18496 uip7 = convert_to_uint(p7) 18497 ip8 = convert_to_int(p8) 18498 fp9 = convert_to_double(p9) 18499 fp10 = convert_to_double(p10) 18500 ip11 = convert_to_int(p11) 18501 keep_elem_refs(pImage, text, p3, p4, p5, p6, p7, p8, p9, p10, p11, 18502 stext, ip3, ip4, ip5, uip6, uip7, ip8, fp9, fp10, ip11) 18503 retval = _flimage_add_text(pImage, stext, ip3, ip4, ip5, uip6, uip7, 18504 ip8, fp9, fp10, ip11) 18505 return retval
18506 18507
18508 -def flimage_add_text_struct(pImage, pImageText):
18509 """ flimage_add_text_struct(pImage, pImageText) -> num. 18510 """ 18511 18512 _flimage_add_text_struct = cfuncproto( 18513 load_so_libflimage(), "flimage_add_text_struct", 18514 cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(FLIMAGE_TEXT)], 18515 """int flimage_add_text_struct(FL_IMAGE * p1, const char * p2) 18516 """) 18517 keep_elem_refs(pImage, pImageText) 18518 retval = _flimage_add_text_struct(pImage, pImageText) 18519 return retval
18520 18521
18522 -def flimage_delete_all_text(pImage):
18523 """ flimage_delete_all_text(pImage) 18524 """ 18525 18526 _flimage_delete_all_text = cfuncproto( 18527 load_so_libflimage(), "flimage_delete_all_text", 18528 None, [cty.POINTER(FL_IMAGE)], 18529 """void flimage_delete_all_text(FL_IMAGE * p1) 18530 """) 18531 keep_elem_refs(pImage) 18532 _flimage_delete_all_text(pImage)
18533 18534
18535 -def flimage_add_marker(pImage, text, p3, p4, p5, p6, p7, p8, p9, p10, p11):
18536 """ flimage_add_marker(pImage, text, p3, p4, p5, p6, p7, p8, p9, p10, p11) -> num. 18537 """ 18538 18539 _flimage_add_marker = cfuncproto( 18540 load_so_libflimage(), "flimage_add_marker", 18541 cty.c_int, [cty.POINTER(FL_IMAGE), STRING, cty.c_double, 18542 cty.c_double, cty.c_double, cty.c_double, cty.c_int, cty.c_int, 18543 cty.c_int, cty.c_uint, cty.c_uint], 18544 """int flimage_add_marker(FL_IMAGE * p1, const char * p2, 18545 double p3, double p4, double p5, double p6, int p7, 18546 int p8, int p9, unsigned int p10, unsigned int p11) 18547 """) 18548 stext = convert_to_string(text) 18549 fp3 = convert_to_double(p3) 18550 fp4 = convert_to_double(p4) 18551 fp5 = convert_to_double(p5) 18552 fp6 = convert_to_double(p6) 18553 ip7 = convert_to_int(p7) 18554 ip8 = convert_to_int(p8) 18555 ip9 = convert_to_int(p9) 18556 uip10 = convert_to_uint(p10) 18557 uip11 = convert_to_uint(p11) 18558 keep_elem_refs(pImage, text, p3, p4, p5, p6, p7, p8, p9, p10, p11, 18559 stext, fp3, fp4, fp5, fp6, ip7, ip8, ip9, uip10, uip11) 18560 retval = _flimage_add_marker(pImage, stext, fp3, fp4, fp5, fp6, ip7, 18561 ip8, ip9, uip10, uip11) 18562 return retval
18563 18564
18565 -def flimage_add_marker_struct(pImage, pImageMarker):
18566 """ flimage_add_marker_struct(pImage, pImageMarker) -> num. 18567 """ 18568 18569 _flimage_add_marker_struct = cfuncproto( 18570 load_so_libflimage(), "flimage_add_marker_struct", 18571 cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(FLIMAGE_MARKER)], 18572 """int flimage_add_marker_struct(FL_IMAGE * p1, const char * p2) 18573 """) 18574 keep_elem_refs(pImage, pImageMarker) 18575 retval = _flimage_add_marker_struct(pImage, pImageMarker) 18576 return retval
18577 18578
18579 -def flimage_define_marker(text1, pImageMarker, text2):
18580 """ flimage_define_marker(text1, pImageMarker, text2) -> num. 18581 """ 18582 18583 _flimage_define_marker = cfuncproto( 18584 load_so_libflimage(), "flimage_define_marker", 18585 cty.c_int, [STRING, cty.POINTER(FLIMAGE_MARKER), STRING], 18586 """int flimage_define_marker(const char *, void ( * ) 18587 (FLIMAGE_MARKER *), const char *) 18588 """) 18589 stext1 = convert_to_string(text1) 18590 stext2 = convert_to_string(text2) 18591 keep_elem_refs(text1, pImageMarker, text2, stext1, stext2) 18592 retval = _flimage_define_marker(stext1, pImageMarker, stext2) 18593 return retval
18594 18595
18596 -def flimage_delete_all_markers(pImage):
18597 """ flimage_delete_all_markers(pImage) 18598 """ 18599 18600 _flimage_delete_all_markers = cfuncproto( 18601 load_so_libflimage(), "flimage_delete_all_markers", 18602 None, [cty.POINTER(FL_IMAGE)], 18603 """void flimage_delete_all_markers(FL_IMAGE * p1) 18604 """) 18605 keep_elem_refs(pImage) 18606 _flimage_delete_all_markers(pImage)
18607 18608
18609 -def flimage_render_annotation(pImage, win):
18610 """ flimage_render_annotation(pImage, win) -> num. 18611 """ 18612 18613 _flimage_render_annotation = cfuncproto( 18614 load_so_libflimage(), "flimage_render_annotation", 18615 cty.c_int, [cty.POINTER(FL_IMAGE), FL_WINDOW], 18616 """int flimage_render_annotation(FL_IMAGE * p1, FL_WINDOW p2) 18617 """) 18618 ulwin = convert_to_Window(win) 18619 keep_elem_refs(pImage, win, ulwin) 18620 retval = _flimage_render_annotation(pImage, ulwin) 18621 return retval
18622 18623
18624 -def flimage_error(pImage, text):
18625 """ flimage_error(pImage, text) 18626 """ 18627 18628 _flimage_error = cfuncproto( 18629 load_so_libflimage(), "flimage_error", 18630 None, [cty.POINTER(FL_IMAGE), STRING], 18631 """void flimage_error(FL_IMAGE * p1, const char * p2) 18632 """) 18633 stext = convert_to_Window(text) 18634 keep_elem_refs(pImage, text, stext) 18635 _flimage_error(pImage, stext)
18636 18637 18638 # built-in format supports 18639
18640 -def flimage_enable_pnm():
18641 """ flimage_enable_pnm() 18642 """ 18643 18644 _flimage_enable_pnm = cfuncproto( 18645 load_so_libflimage(), "flimage_enable_pnm", 18646 None, [], 18647 """void flimage_enable_pnm() 18648 """) 18649 _flimage_enable_pnm()
18650 18651
18652 -def flimage_set_fits_bits(p1):
18653 """ flimage_set_fits_bits(p1) -> num. 18654 """ 18655 18656 _flimage_set_fits_bits = cfuncproto( 18657 load_so_libflimage(), "flimage_set_fits_bits", 18658 cty.c_int, [cty.c_int], 18659 """int flimage_set_fits_bits(int p1) 18660 """) 18661 ip1 = convert_to_int(p1) 18662 keep_elem_refs(p1, ip1) 18663 retval = _flimage_set_fits_bits(ip1) 18664 return retval
18665 18666
18667 -def flimage_jpeg_output_options(pImageJpegOption):
18668 """ flimage_jpeg_output_options(pImageJpegOption) 18669 """ 18670 18671 _flimage_jpeg_output_options = cfuncproto( 18672 load_so_libflimage(), "flimage_jpeg_output_options", 18673 None, [cty.POINTER(FLIMAGE_JPEG_OPTION)], 18674 """void flimage_jpeg_output_options(FLIMAGE_JPEG_OPTION * p1) 18675 """) 18676 keep_elem_refs(pImageJpegOption) 18677 _flimage_jpeg_output_options(pImageJpegOption)
18678 18679
18680 -def flimage_pnm_output_options(p1):
18681 """ flimage_pnm_output_options(p1) 18682 """ 18683 18684 _flimage_pnm_output_options = cfuncproto( 18685 load_so_libflimage(), "flimage_pnm_output_options", 18686 None, [cty.c_int], 18687 """void flimage_pnm_output_options(int p1) 18688 """) 18689 ip1 = convert_to_int(p1) 18690 keep_elem_refs(p1, ip1) 18691 _flimage_pnm_output_options(ip1)
18692 18693
18694 -def flimage_gif_output_options(p1):
18695 """ flimage_gif_output_options(p1) 18696 """ 18697 18698 _flimage_gif_output_options = cfuncproto( 18699 load_so_libflimage(), "flimage_gif_output_options", 18700 None, [cty.c_int], 18701 """void flimage_gif_output_options(int p1) 18702 """) 18703 ip1 = convert_to_int(p1) 18704 keep_elem_refs(p1, ip1) 18705 _flimage_gif_output_options(ip1)
18706 18707
18708 -def flimage_ps_options():
18709 """ flimage_ps_options() -> flps_control class 18710 """ 18711 18712 _flimage_ps_options = cfuncproto( 18713 load_so_libflimage(), "flimage_ps_options", 18714 cty.POINTER(FLPS_CONTROL), [], 18715 """FLPS_CONTROL * flimage_ps_options() 18716 """) 18717 retval = _flimage_ps_options() 18718 return retval
18719 18720 18721 flimage_jpeg_options = flimage_jpeg_output_options 18722 flimage_pnm_options = flimage_pnm_output_options 18723 flimage_gif_options = flimage_gif_output_options 18724 18725
18726 -def flimage_get_number_of_formats():
18727 """ flimage_get_number_of_formats() -> num. 18728 """ 18729 18730 _flimage_get_number_of_formats = cfuncproto( 18731 load_so_libflimage(), "flimage_get_number_of_formats", 18732 cty.c_int, [], 18733 """int flimage_get_number_of_formats() 18734 """) 18735 retval = _flimage_get_number_of_formats() 18736 return retval
18737 18738
18739 -def flimage_get_format_info(p1):
18740 """ flimage_get_format_info(p1) -> format_info class instance 18741 """ 18742 18743 _flimage_get_format_info = cfuncproto( 18744 load_so_libflimage(), "flimage_get_format_info", 18745 cty.POINTER(FLIMAGE_FORMAT_INFO), [cty.c_int], 18746 """const char * flimage_get_format_info(int p1) 18747 """) 18748 ip1 = convert_to_int(p1) 18749 keep_elem_refs(p1, ip1) 18750 retval = _flimage_get_format_info(ip1) 18751 return retval
18752 18753
18754 -def fl_get_matrix(nrows, ncols, esize):
18755 """ fl_get_matrix(nrows, ncols, esize) -> ? 18756 """ 18757 18758 _fl_get_matrix = cfuncproto( 18759 load_so_libflimage(), "fl_get_matrix", 18760 cty.c_void_p, [cty.c_int, cty.c_int, cty.c_uint], 18761 """void * fl_get_matrix(int p1, int p2, unsigned int p3) 18762 """) 18763 inrows = convert_to_int(nrows) 18764 incols = convert_to_int(ncols) 18765 uiesize = convert_to_uint(esize) 18766 keep_elem_refs(nrows, ncols, esize, inrows, incols, uiesize) 18767 retval = _fl_get_matrix(inrows, incols, uiesize) 18768 return retval
18769 18770
18771 -def fl_make_matrix(nrows, ncols, esize, mem):
18772 """ 18773 fl_make_matrix(nrows, ncols, esize, mem) -> ? 18774 18775 Makes a matrix out of a given piece of memory. 18776 18777 @param nrows : number of rows 18778 @param ncols : number of columns 18779 @param esize : size of matrix 18780 @param mem : memory 18781 """ 18782 18783 _fl_make_matrix = cfuncproto( 18784 load_so_libflimage(), "fl_make_matrix", 18785 cty.c_void_p, [cty.c_int, cty.c_int, cty.c_uint, cty.c_void_p], 18786 """void * fl_make_matrix(int p1, int p2, unsigned int p3, 18787 void * p4) 18788 """) 18789 inrows = convert_to_int(nrows) 18790 incols = convert_to_int(ncols) 18791 uiesize = convert_to_uint(esize) 18792 pmem = cty.cast(mem, cty.c_void_p) 18793 keep_elem_refs(nrows, ncols, esize, mem, inrows, incols, uiesize, pmem) 18794 retval = _fl_make_matrix(inrows, incols, uiesize, pmem) 18795 return retval
18796 18797
18798 -def fl_free_matrix(mtrx):
18799 """ fl_free_matrix(mtrx) 18800 """ 18801 18802 _fl_free_matrix = cfuncproto( 18803 load_so_libflimage(), "fl_free_matrix", 18804 None, [cty.c_void_p], 18805 """void fl_free_matrix(void * p1) 18806 """) 18807 pmtrx = cty.cast(mtrx, cty.c_void_p) 18808 keep_elem_refs(mtrx, pmtrx) 18809 _fl_free_matrix(pmtrx)
18810 18811 18812 # This function is retained for compatibility reasons only. 18813 # It returns 1 always.
18814 -def fl_init_RGBdatabase(text):
18815 """ fl_init_RGBdatabase(text) -> num. 18816 """ 18817 18818 _fl_init_RGBdatabase = cfuncproto( 18819 load_so_libflimage(), "fl_init_RGBdatabase", 18820 cty.c_int, [STRING], 18821 """int fl_init_RGBdatabase(const char * p1) 18822 """) 18823 stext = convert_to_string(text) 18824 keep_elem_refs(text, stext) 18825 retval = _fl_init_RGBdatabase(stext) 18826 return retval
18827 18828
18829 -def fl_lookup_RGBcolor(text, p2, p3, p4):
18830 """ fl_lookup_RGBcolor(text, p2, p3, p4) -> num. 18831 """ 18832 18833 _fl_lookup_RGBcolor = cfuncproto( 18834 load_so_libflimage(), "fl_lookup_RGBcolor", 18835 cty.c_int, [STRING, cty.POINTER(cty.c_int), \ 18836 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)], 18837 """int fl_lookup_RGBcolor(const char * p1, int * p2, 18838 int * p3, int * p4) 18839 """) 18840 stext = convert_to_string(text) 18841 keep_elem_refs(text, p2, p3, p4) 18842 retval = _fl_lookup_RGBcolor(stext, p2, p3, p4) 18843 return retval
18844 18845 18846 FLIMAGE_Identify = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FILE)) 18847 FLIMAGE_Description = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_IMAGE)) 18848 FLIMAGE_Read_Pixels = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_IMAGE)) 18849 FLIMAGE_Write_Image = cty.CFUNCTYPE(cty.c_int, cty.POINTER(FL_IMAGE)) 18850
18851 -def flimage_add_format(p1, p2, p3, p4, py_ImageIdentify, py_ImageDescription, 18852 py_ImageReadPixels, py_ImageWriteImage):
18853 """ flimage_add_format(p1, p2, p3, p4, py_ImageIdentify, 18854 py_ImageDescription, py_ImageReadPixels, py_ImageWriteImage) -> num. 18855 """ 18856 18857 _flimage_add_format = cfuncproto( 18858 load_so_libflimage(), "flimage_add_format", 18859 cty.c_int, [STRING, STRING, STRING, cty.c_int, FLIMAGE_Identify, 18860 FLIMAGE_Description, FLIMAGE_Read_Pixels, FLIMAGE_Write_Image], 18861 """int flimage_add_format(const char * p1, const char * p2, 18862 const char * p3, int p4, FLIMAGE_Identify p5, 18863 FLIMAGE_Description p6, FLIMAGE_Read_Pixels p7, 18864 FLIMAGE_Write_Image p8) 18865 """) 18866 sp1 = convert_to_string(p1) 18867 sp2 = convert_to_string(p2) 18868 sp3 = convert_to_string(p3) 18869 ip4 = convert_to_int(p4) 18870 c_ImageIdentify = FLIMAGE_Identify(py_ImageIdentify) 18871 c_ImageDescription = FLIMAGE_Description(py_ImageDescription) 18872 c_ImageReadPixels = FLIMAGE_Read_Pixels(py_ImageReadPixels) 18873 c_ImageWriteImage = FLIMAGE_Write_Image(py_ImageWriteImage) 18874 keep_cfunc_refs(c_ImageIdentify, py_ImageIdentify, c_ImageDescription, \ 18875 py_ImageDescription, c_ImageReadPixels, py_ImageReadPixels, 18876 c_ImageWriteImage, py_ImageWriteImage) 18877 keep_elem_refs(p1, p2, p3, p4, sp1, sp2, sp3, ip4) 18878 retval = _flimage_add_format(sp1, sp2, sp3, ip4, c_ImageIdentify, \ 18879 c_ImageDescription, c_ImageReadPixels, \ 18880 c_ImageWriteImage) 18881 return retval
18882 18883
18884 -def flimage_set_annotation_support(p1, p2):
18885 """ flimage_set_annotation_support(p1, p2) 18886 """ 18887 18888 _flimage_set_annotation_support = cfuncproto( 18889 load_so_libflimage(), "flimage_set_annotation_support", 18890 None, [cty.c_int, cty.c_int], 18891 """void flimage_set_annotation_support(int p1, int p2) 18892 """) 18893 ip1 = convert_to_int(p1) 18894 ip2 = convert_to_int(p2) 18895 keep_elem_refs(p1, p2, ip1, ip2) 18896 _flimage_set_annotation_support(ip1, ip2)
18897 18898
18899 -def flimage_getcolormap(pImage):
18900 """ flimage_getcolormap(pImage) -> num. 18901 """ 18902 18903 _flimage_getcolormap = cfuncproto( 18904 load_so_libflimage(), "flimage_getcolormap", 18905 cty.c_int, [cty.POINTER(FL_IMAGE)], 18906 """int flimage_getcolormap(FL_IMAGE * p1) 18907 """) 18908 keep_elem_refs(pImage) 18909 retval = _flimage_getcolormap(pImage) 18910 return retval
18911 18912
18913 -def fl_select_mediancut_quantizer():
18914 """ fl_select_mediancut_quantizer() 18915 """ 18916 18917 _fl_select_mediancut_quantizer = cfuncproto( 18918 load_so_libflimage(), "fl_select_mediancut_quantizer", 18919 None, [], 18920 """void fl_select_mediancut_quantizer() 18921 """) 18922 _fl_select_mediancut_quantizer()
18923 18924 18925 # simple image processing routines 18926
18927 -def flimage_convolve(pImage, p2, p3, p4):
18928 """ flimage_convolve(pImage, p2, p3, p4) -> num. 18929 """ 18930 18931 _flimage_convolve = cfuncproto( 18932 load_so_libflimage(), "flimage_convolve", 18933 cty.c_int, [cty.POINTER(FL_IMAGE), 18934 cty.POINTER(cty.POINTER(cty.c_int)), cty.c_int, cty.c_int], 18935 """int flimage_convolve(FL_IMAGE * p1, int * * p2, int p3, 18936 int p4) 18937 """) 18938 ip3 = convert_to_int(p3) 18939 ip4 = convert_to_int(p4) 18940 keep_elem_refs(pImage, p2, p3, p4, ip3, ip4) 18941 retval = _flimage_convolve(pImage, p2, ip3, ip4) 18942 return retval
18943 18944
18945 -def flimage_convolvea(pImage, p2, p3, p4):
18946 """ flimage_convolvea(pImage, p2, p3, p4) -> num. 18947 """ 18948 18949 _flimage_convolvea = cfuncproto( 18950 load_so_libflimage(), "flimage_convolvea", 18951 cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(cty.c_int), 18952 cty.c_int, cty.c_int], 18953 """int flimage_convolvea(FL_IMAGE * p1, int * p2, int p3, int p4) 18954 """) 18955 keep_elem_refs(pImage, p2, p3, p4) 18956 retval = _flimage_convolvea(pImage, p2, p3, p4) 18957 return retval
18958 18959
18960 -def flimage_tint(pImage, p2, p3):
18961 """ flimage_tint(pImage, p2, p3) -> num. 18962 """ 18963 18964 _flimage_tint = cfuncproto( 18965 load_so_libflimage(), "flimage_tint", 18966 cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_uint, cty.c_double], 18967 """int flimage_tint(FL_IMAGE * p1, unsigned int p2, double p3) 18968 """) 18969 keep_elem_refs(pImage, p2, p3) 18970 retval = _flimage_tint(pImage, p2, p3) 18971 return retval
18972 18973
18974 -def flimage_rotate(pImage, p2, p3):
18975 """ flimage_rotate(pImage, p2, p3) -> num. 18976 """ 18977 18978 _flimage_rotate = cfuncproto( 18979 load_so_libflimage(), "flimage_rotate", 18980 cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int], 18981 """int flimage_rotate(FL_IMAGE * p1, int p2, int p3) 18982 """) 18983 ip2 = convert_to_int(p2) 18984 ip3 = convert_to_int(p3) 18985 keep_elem_refs(pImage, p2, p3, ip2, ip3) 18986 retval = _flimage_rotate(pImage, ip2, ip3) 18987 return retval
18988 18989
18990 -def flimage_flip(pImage, p2):
18991 """ flimage_flip(pImage, p2) -> num. 18992 """ 18993 18994 _flimage_flip = cfuncproto( 18995 load_so_libflimage(), "flimage_flip", 18996 cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int], 18997 """int flimage_flip(FL_IMAGE * p1, int p2) 18998 """) 18999 ip2 = convert_to_int(p2) 19000 keep_elem_refs(pImage, p2, ip2) 19001 retval = _flimage_flip(pImage, ip2) 19002 return retval
19003 19004
19005 -def flimage_scale(pImage, p2, p3, p4):
19006 """ flimage_scale(pImage, p2, p3, p4) -> num. 19007 """ 19008 19009 _flimage_scale = cfuncproto( 19010 load_so_libflimage(), "flimage_scale", 19011 cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int, 19012 cty.c_int], 19013 """int flimage_scale(FL_IMAGE * p1, int p2, int p3, int p4) 19014 """) 19015 ip2 = convert_to_int(p2) 19016 ip3 = convert_to_int(p3) 19017 ip4 = convert_to_int(p4) 19018 keep_elem_refs(pImage, p2, p3, p4, ip2, ip3, ip4) 19019 retval = _flimage_scale(pImage, ip2, ip3, ip4) 19020 return retval
19021 19022
19023 -def flimage_warp(pImage, p2, p3, p4, p5):
19024 """ flimage_warp(pImage, p2, p3, p4, p5) -> num. 19025 """ 19026 19027 _flimage_warp = cfuncproto( 19028 load_so_libflimage(), "flimage_warp", 19029 cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(cty.c_float * 2), 19030 cty.c_int, cty.c_int, cty.c_int], 19031 """int flimage_warp(FL_IMAGE * p1, float * p2, int p3, int p4, 19032 int p5) 19033 """) 19034 ip3 = convert_to_int(p3) 19035 ip4 = convert_to_int(p4) 19036 ip5 = convert_to_int(p5) 19037 keep_elem_refs(pImage, p2, p3, p4, p5, ip3, ip4, ip5) 19038 retval = _flimage_warp(pImage, p2, ip3, ip4, ip5) 19039 return retval
19040 19041
19042 -def flimage_autocrop(pImage, p2):
19043 """ flimage_autocrop(pImage, p2) -> num. 19044 """ 19045 19046 _flimage_autocrop = cfuncproto( 19047 load_so_libflimage(), "flimage_autocrop", 19048 cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_uint], 19049 """int flimage_autocrop(FL_IMAGE * p1, unsigned int p2) 19050 """) 19051 uip2 = convert_to_uint(p2) 19052 keep_elem_refs(pImage, p2, uip2) 19053 retval = _flimage_autocrop(pImage, uip2) 19054 return retval
19055 19056 19057 #def flimage_get_autocrop(pImage, bk, xl, yt, xr, yb) *API change*
19058 -def flimage_get_autocrop(pImage, bk):
19059 """ flimage_get_autocrop(pImage, bk) -> num., xl, yt, xr, yb 19060 """ 19061 19062 _flimage_get_autocrop = cfuncproto( 19063 load_so_libflimage(), "flimage_get_autocrop", 19064 cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_uint, 19065 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 19066 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)], 19067 """int flimage_get_autocrop(FL_IMAGE * p1, unsigned int p2, 19068 int * p3, int * p4, int * p5, int * p6) 19069 """) 19070 uibk = convert_to_uint(bk) 19071 xl, pxl = make_int_and_pointer() 19072 yt, pyt = make_int_and_pointer() 19073 xr, pxr = make_int_and_pointer() 19074 yb, pyb = make_int_and_pointer() 19075 keep_elem_refs(pImage, bk, uibk, xl, pxl, yt, pyt, xr, pxr, yb, pyb) 19076 retval = _flimage_get_autocrop(pImage, uibk, pxl, pyt, pxr, pyb) 19077 return retval, xl, yt, xr, yb
19078 19079
19080 -def flimage_crop(pImage, p2, p3, p4, p5):
19081 """ flimage_crop(pImage, p2, p3, p4, p5) -> num. 19082 """ 19083 19084 _flimage_crop = cfuncproto( 19085 load_so_libflimage(), "flimage_crop", 19086 cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int, 19087 cty.c_int, cty.c_int], 19088 """int flimage_crop(FL_IMAGE * p1, int p2, int p3, 19089 int p4, int p5) 19090 """) 19091 ip2 = convert_to_int(p2) 19092 ip3 = convert_to_int(p3) 19093 ip4 = convert_to_int(p4) 19094 ip5 = convert_to_int(p5) 19095 keep_elem_refs(pImage, p2, p3, p4, p5, ip2, ip3, ip4, ip5) 19096 retval = _flimage_crop(pImage, ip2, ip3, ip4, ip5) 19097 return retval
19098 19099
19100 -def flimage_replace_pixel(pImage, p2, p3):
19101 """ flimage_replace_pixel(pImage, p2, p3) -> num. 19102 """ 19103 19104 _flimage_replace_pixel = cfuncproto( 19105 load_so_libflimage(), "flimage_replace_pixel", 19106 cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_uint, cty.c_uint], 19107 """int flimage_replace_pixel(FL_IMAGE * p1, unsigned int p2, 19108 unsigned int p3) 19109 """) 19110 uip2 = convert_to_uint(p2) 19111 uip3 = convert_to_uint(p3) 19112 keep_elem_refs(pImage, p2, p3, uip2, uip3) 19113 retval = _flimage_replace_pixel(pImage, uip2, uip3) 19114 return retval
19115 19116
19117 -def flimage_transform_pixels(pImage, red, green, blue):
19118 """ flimage_transform_pixels(pImage, red, green, blue) -> num. 19119 """ 19120 19121 _flimage_transform_pixels = cfuncproto( 19122 load_so_libflimage(), "flimage_transform_pixels", 19123 cty.c_int, [cty.POINTER(FL_IMAGE), cty.POINTER(cty.c_int), 19124 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)], 19125 """int flimage_transform_pixels(FL_IMAGE * p1, int * p2, 19126 int * p3, int * p4) 19127 """) 19128 pred = cty.cast(red, cty.POINTER(cty.c_int)) 19129 pgreen = cty.cast(green, cty.POINTER(cty.c_int)) 19130 pblue = cty.cast(blue, cty.POINTER(cty.c_int)) 19131 keep_elem_refs(pImage, red, green, blue, pred, pgreen, pblue) 19132 retval = _flimage_transform_pixels(pImage, pred, pgreen, pblue) 19133 return retval
19134 19135
19136 -def flimage_windowlevel(pImage, p2, p3):
19137 """ flimage_windowlevel(pImage, p2, p3) -> num. 19138 """ 19139 19140 _flimage_windowlevel = cfuncproto( 19141 load_so_libflimage(), "flimage_windowlevel", 19142 cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int], 19143 """int flimage_windowlevel(FL_IMAGE * p1, int p2, int p3) 19144 """) 19145 ip2 = convert_to_int(p2) 19146 ip3 = convert_to_int(p3) 19147 keep_elem_refs(pImage, p2, p3, ip2, ip3) 19148 retval = _flimage_windowlevel(pImage, ip2, ip3) 19149 return retval
19150 19151
19152 -def flimage_enhance(pImage, p2):
19153 """ flimage_enhance(pImage, p2) -> num. 19154 """ 19155 19156 _flimage_enhance = cfuncproto( 19157 load_so_libflimage(), "flimage_enhance", 19158 cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_int], 19159 """int flimage_enhance(FL_IMAGE * p1, int p2) 19160 """) 19161 ip2 = convert_to_int(p2) 19162 keep_elem_refs(pImage, p2, ip2) 19163 retval = _flimage_enhance(pImage, ip2) 19164 return retval
19165 19166
19167 -def flimage_from_pixmap(pImage, pixmap):
19168 """ flimage_from_pixmap(pImage, pixmap) -> num. 19169 """ 19170 19171 _flimage_from_pixmap = cfuncproto( 19172 load_so_libflimage(), "flimage_from_pixmap", 19173 cty.c_int, [cty.POINTER(FL_IMAGE), Pixmap], 19174 """int flimage_from_pixmap(FL_IMAGE * p1, Pixmap p2) 19175 """) 19176 ulpixmap = convert_to_Pixmap(pixmap) 19177 keep_elem_refs(pImage, pixmap, ulpixmap) 19178 retval = _flimage_from_pixmap(pImage, ulpixmap) 19179 return retval
19180 19181
19182 -def flimage_to_pixmap(pImage, win):
19183 """ flimage_to_pixmap(pImage, win) -> pixmap 19184 """ 19185 19186 _flimage_to_pixmap = cfuncproto( 19187 load_so_libflimage(), "flimage_to_pixmap", 19188 Pixmap, [cty.POINTER(FL_IMAGE), FL_WINDOW], 19189 """Pixmap flimage_to_pixmap(FL_IMAGE * p1, FL_WINDOW p2) 19190 """) 19191 ulwin = convert_to_Window(win) 19192 keep_elem_refs(pImage, win, ulwin) 19193 retval = _flimage_to_pixmap(pImage, ulwin) 19194 return retval
19195 19196
19197 -def flimage_dup(pImage):
19198 """ flimage_dup(pImage) -> pImage 19199 """ 19200 19201 _flimage_dup = cfuncproto( 19202 load_so_libflimage(), "flimage_dup", 19203 cty.POINTER(FL_IMAGE), [cty.POINTER(FL_IMAGE)], 19204 """FL_IMAGE * flimage_dup(FL_IMAGE * p1) 19205 """) 19206 keep_elem_refs(pImage) 19207 retval = _flimage_dup(pImage) 19208 return retval
19209 19210 19211 # Miscellaneous prototypes 19212
19213 -def fl_get_submatrix(inmtrx, rows, cols, r1, c1, rs, cs, esize):
19214 """ fl_get_submatrix(inmtrx, rows, cols, r1, c1, rs, cs, esize) -> ? 19215 """ 19216 19217 _fl_get_submatrix = cfuncproto( 19218 load_so_libflimage(), "fl_get_submatrix", 19219 cty.c_void_p, [cty.c_void_p, cty.c_int, cty.c_int, cty.c_int, 19220 cty.c_int, cty.c_int, cty.c_int, cty.c_uint], 19221 """void * fl_get_submatrix(void * p1, int p2, int p3, int p4, 19222 int p5, int p6, int p7, unsigned int p8) 19223 """) 19224 pinmtrx = cty.cast(inmtrx, cty.c_void_p) 19225 irows = convert_to_int(rows) 19226 icols = convert_to_int(cols) 19227 ir1 = convert_to_int(r1) 19228 ic1 = convert_to_int(c1) 19229 irs = convert_to_int(rs) 19230 ics = convert_to_int(cs) 19231 uiesize = convert_to_uint(esize) 19232 keep_elem_refs(inmtrx, rows, cols, r1, c1, rs, cs, esize, pinmtrx, \ 19233 irows, icols, ir1, ic1, irs, ics, uiesize) 19234 retval = _fl_get_submatrix(pinmtrx, irows, icols, ir1, ic1, irs, ics, \ 19235 uiesize) 19236 return retval
19237 19238
19239 -def fl_j2pass_quantize_packed(p1, p2, p3, p4, p5, p6, p7, p8, p9, pImage):
19240 """ fl_j2pass_quantize_packed(p1, p2, p3, p4, p5, p6, p7, p8, p9, pImage) -> num. 19241 """ 19242 19243 _fl_j2pass_quantize_packed = cfuncproto( 19244 load_so_libflimage(), "fl_j2pass_quantize_packed", 19245 cty.c_int, [cty.POINTER(cty.POINTER(cty.c_uint)), cty.c_int, 19246 cty.c_int, cty.c_int, cty.POINTER(cty.POINTER(cty.c_ushort)), 19247 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 19248 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 19249 cty.POINTER(FL_IMAGE)], 19250 """int fl_j2pass_quantize_packed(unsigned int * * p1, int p2, 19251 int p3, int p4, short unsigned int * * p5, int * p6, 19252 int * p7, int * p8, int * p9, FL_IMAGE * p10) 19253 """) 19254 ip2 = convert_to_int(p2) 19255 ip3 = convert_to_int(p3) 19256 ip4 = convert_to_int(p4) 19257 keep_elem_refs(p1, p2, p3, p4, p5, p6, p7, p8, p9, pImage, ip2, ip3, ip4) 19258 retval = _fl_j2pass_quantize_packed(p1, ip2, ip3, ip4, p5, p6, p7, p8, \ 19259 p9, pImage) 19260 return retval
19261 19262
19263 -def fl_j2pass_quantize_rgb(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, pImage):
19264 """ fl_j2pass_quantize_rgb(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, pImage) -> num. 19265 """ 19266 19267 _fl_j2pass_quantize_rgb = cfuncproto( 19268 load_so_libflimage(), "fl_j2pass_quantize_rgb", 19269 cty.c_int, [cty.POINTER(cty.POINTER(cty.c_ubyte)), 19270 cty.POINTER(cty.POINTER(cty.c_ubyte)), 19271 cty.POINTER(cty.POINTER(cty.c_ubyte)), cty.c_int, cty.c_int, 19272 cty.c_int, cty.POINTER(cty.POINTER(cty.c_ushort)), 19273 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 19274 cty.POINTER(cty.c_int), cty.POINTER(cty.c_int), 19275 cty.POINTER(FL_IMAGE)], 19276 """int fl_j2pass_quantize_rgb(unsigned char * * p1, 19277 unsigned char * * p2, unsigned char * * p3, int p4, int p5, 19278 int p6, short unsigned int * * p7, int * p8, int * p9, 19279 int * p10, int * p11, FL_IMAGE * p12) 19280 """) 19281 ip4 = convert_to_int(p4) 19282 ip5 = convert_to_int(p5) 19283 ip6 = convert_to_int(p6) 19284 keep_elem_refs(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, pImage, 19285 ip4, ip5, ip6) 19286 retval = _fl_j2pass_quantize_rgb(p1, p2, p3, ip4, ip5, ip6, p7, p8, p9, \ 19287 p10, p11, pImage) 19288 return retval
19289 19290
19291 -def fl_make_submatrix(in_, rows, cols, r1, c1, rs, cs, esize):
19292 """ fl_make_submatrix(in_, rows, cols, r1, c1, rs, cs, esize) -> ? 19293 """ 19294 19295 _fl_make_submatrix = cfuncproto( 19296 load_so_libflimage(), "fl_make_submatrix", 19297 cty.c_void_p, [cty.c_void_p, cty.c_int, cty.c_int, cty.c_int, 19298 cty.c_int, cty.c_int, cty.c_int, cty.c_uint], 19299 """void * fl_make_submatrix(void * p1, int p2, int p3, int p4, 19300 int p5, int p6, int p7, unsigned int p8) 19301 """) 19302 irows = convert_to_int(rows) 19303 icols = convert_to_int(cols) 19304 ir1 = convert_to_int(r1) 19305 ic1 = convert_to_int(c1) 19306 irs = convert_to_int(rs) 19307 ics = convert_to_int(cs) 19308 uiesize = convert_to_uint(esize) 19309 keep_elem_refs(in_, rows, cols, r1, c1, rs, cs, esize, irows, icols, \ 19310 ir1, ic1, irs, ics, uiesize) 19311 retval = _fl_make_submatrix(in_, irows, icols, ir1, ic1, irs, ics, \ 19312 uiesize) 19313 return retval
19314 19315
19316 -def fl_pack_bits(p1, p2, p3):
19317 """ fl_pack_bits(p1, p2, p3) 19318 """ 19319 19320 _fl_pack_bits = cfuncproto( 19321 load_so_libflimage(), "fl_pack_bits", 19322 None, [cty.POINTER(cty.c_ubyte), cty.POINTER(cty.c_ushort), 19323 cty.c_int], 19324 """void fl_pack_bits(unsigned char * p1, short unsigned int * p2, 19325 int p3) 19326 """) 19327 ip3 = convert_to_int(p3) 19328 keep_elem_refs(p1, p2, p3, ip3) 19329 _fl_pack_bits(p1, p2, ip3)
19330 19331
19332 -def fl_unpack_bits(p1, p2, p3):
19333 """ fl_unpack_bits(p1, p2, p3) 19334 """ 19335 19336 _fl_unpack_bits = cfuncproto( 19337 load_so_libflimage(), "fl_unpack_bits", 19338 None, [cty.POINTER(cty.c_ushort), cty.POINTER(cty.c_ubyte), 19339 cty.c_int], 19340 """void fl_unpack_bits(short unsigned int * p1, 19341 unsigned char * p2, int p3) 19342 """) 19343 ip3 = convert_to_int(p3) 19344 keep_elem_refs(p1, p2, p3, ip3) 19345 _fl_unpack_bits(p1, p2, ip3)
19346 19347
19348 -def fl_value_to_bits(p1):
19349 """ fl_value_to_bits(p1) -> num. 19350 """ 19351 19352 _fl_value_to_bits = cfuncproto( 19353 load_so_libflimage(), "fl_value_to_bits", 19354 cty.c_uint, [cty.c_uint], 19355 """)unsigned int fl_value_to_bits(unsigned int p1) 19356 """) 19357 uip1 = convert_to_uint(p1) 19358 keep_elem_refs(p1, uip1) 19359 retval = _fl_value_to_bits(uip1) 19360 return retval
19361 19362
19363 -def flimage_add_comments(pImage, p2, p3):
19364 """ flimage_add_comments(pImage, p2, p3) 19365 """ 19366 19367 _flimage_add_comments = cfuncproto( 19368 load_so_libflimage(), "flimage_add_comments", 19369 None, [cty.POINTER(FL_IMAGE), STRING, cty.c_int], 19370 """void flimage_add_comments(FL_IMAGE * p1, const char * p2, 19371 int p3) 19372 """) 19373 sp2 = convert_to_string(p2) 19374 ip3 = convert_to_int(p3) 19375 keep_elem_refs(pImage, p2, p3, sp2, ip3) 19376 _flimage_add_comments(pImage, sp2, ip3)
19377 19378
19379 -def flimage_color_to_pixel(pImage, p2, p3, p4, p5):
19380 """ flimage_color_to_pixel(pImage, p2, p3, p4, p5) -> num. 19381 """ 19382 19383 _flimage_color_to_pixel = cfuncproto( 19384 load_so_libflimage(), "flimage_color_to_pixel", 19385 cty.c_ulong, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int, 19386 cty.c_int, cty.POINTER(cty.c_int)], 19387 """)long unsigned int flimage_color_to_pixel(FL_IMAGE * p1, 19388 int p2, int p3, int p4, int * p5) 19389 """) 19390 ip2 = convert_to_int(p2) 19391 ip3 = convert_to_int(p3) 19392 ip4 = convert_to_int(p4) 19393 keep_elem_refs(pImage, p2, p3, p4, p5, ip2, ip3, ip4) 19394 retval = _flimage_color_to_pixel(pImage, ip2, ip3, ip4, p5) 19395 return retval
19396 19397
19398 -def flimage_combine(pImage1, pImage2, p3):
19399 """ flimage_combine(pImage1, pImage2, p3) -> pImage 19400 """ 19401 19402 _flimage_combine = cfuncproto( 19403 load_so_libflimage(), "flimage_combine", 19404 cty.POINTER(FL_IMAGE), [cty.POINTER(FL_IMAGE), 19405 cty.POINTER(FL_IMAGE), cty.c_double], 19406 """FL_IMAGE * flimage_combine(FL_IMAGE * p1, FL_IMAGE * p2, 19407 double p3) 19408 """) 19409 fp3 = convert_to_double(p3) 19410 keep_elem_refs(pImage1, pImage2, p3, fp3) 19411 retval = _flimage_combine(pImage1, pImage2, fp3) 19412 return retval
19413 19414
19415 -def flimage_display_markers(pImage):
19416 """ flimage_display_markers(pImage) 19417 """ 19418 19419 _flimage_display_markers = cfuncproto( 19420 load_so_libflimage(), "flimage_display_markers", 19421 None, [cty.POINTER(FL_IMAGE)], 19422 """void flimage_display_markers(FL_IMAGE * p1) 19423 """) 19424 keep_elem_refs(pImage) 19425 _flimage_display_markers(pImage)
19426 19427
19428 -def flimage_dup_(pImage, p2):
19429 """ flimage_dup_(pImage, p2) -> pImage 19430 """ 19431 19432 _flimage_dup_ = cfuncproto( 19433 load_so_libflimage(), "flimage_dup_", 19434 cty.POINTER(FL_IMAGE), [cty.POINTER(FL_IMAGE), cty.c_int], 19435 """FL_IMAGE * flimage_dup_(FL_IMAGE * p1, int p2) 19436 """) 19437 ip2 = convert_to_int(p2) 19438 keep_elem_refs(pImage, p2, ip2) 19439 retval = _flimage_dup_(pImage, ip2) 19440 return retval
19441 19442
19443 -def flimage_enable_bmp():
19444 """ flimage_enable_bmp() 19445 """ 19446 19447 _flimage_enable_bmp = cfuncproto( 19448 load_so_libflimage(), "flimage_enable_bmp", 19449 None, [], 19450 """void flimage_enable_bmp() 19451 """) 19452 _flimage_enable_bmp()
19453 19454
19455 -def flimage_enable_fits():
19456 """ flimage_enable_fits() 19457 """ 19458 19459 _flimage_enable_fits = cfuncproto( 19460 load_so_libflimage(), "flimage_enable_fits", 19461 None, [], 19462 """void flimage_enable_fits() 19463 """) 19464 _flimage_enable_fits()
19465 19466
19467 -def flimage_enable_genesis():
19468 """ flimage_enable_genesis() 19469 """ 19470 19471 _flimage_enable_genesis = cfuncproto( 19472 load_so_libflimage(), "flimage_enable_genesis", 19473 None, [], 19474 """void flimage_enable_genesis() 19475 """) 19476 _flimage_enable_genesis()
19477 19478
19479 -def flimage_enable_gif():
19480 """ flimage_enable_gif() 19481 """ 19482 19483 _flimage_enable_gif = cfuncproto( 19484 load_so_libflimage(), "flimage_enable_gif", 19485 None, [], 19486 """void flimage_enable_gif() 19487 """) 19488 _flimage_enable_gif()
19489 19490
19491 -def flimage_enable_gzip():
19492 """ flimage_enable_gzip() 19493 """ 19494 19495 _flimage_enable_gzip = cfuncproto( 19496 load_so_libflimage(), "flimage_enable_gzip", 19497 None, [], 19498 """void flimage_enable_gzip() 19499 """) 19500 _flimage_enable_gzip()
19501 19502
19503 -def flimage_enable_jpeg():
19504 """ flimage_enable_jpeg() 19505 """ 19506 19507 _flimage_enable_jpeg = cfuncproto( 19508 load_so_libflimage(), "flimage_enable_jpeg", 19509 None, [], 19510 """void flimage_enable_jpeg() 19511 """) 19512 _flimage_enable_jpeg()
19513 19514
19515 -def flimage_enable_png():
19516 """ flimage_enable_png() 19517 """ 19518 19519 _flimage_enable_png = cfuncproto( 19520 load_so_libflimage(), "flimage_enable_png", 19521 None, [], 19522 """void flimage_enable_png() 19523 """) 19524 _flimage_enable_png()
19525 19526
19527 -def flimage_enable_ps():
19528 """ flimage_enable_ps() 19529 """ 19530 19531 _flimage_enable_ps = cfuncproto( 19532 load_so_libflimage(), "flimage_enable_ps", 19533 None, [], 19534 """void flimage_enable_ps() 19535 """) 19536 _flimage_enable_ps()
19537 19538
19539 -def flimage_enable_sgi():
19540 """ flimage_enable_sgi() 19541 """ 19542 19543 _flimage_enable_sgi = cfuncproto( 19544 load_so_libflimage(), "flimage_enable_sgi", 19545 None, [], 19546 """void flimage_enable_sgi() 19547 """) 19548 _flimage_enable_sgi()
19549 19550
19551 -def flimage_enable_tiff():
19552 """ flimage_enable_tiff() 19553 """ 19554 19555 _flimage_enable_tiff = cfuncproto( 19556 load_so_libflimage(), "flimage_enable_tiff", 19557 None, [], 19558 """void flimage_enable_tiff() 19559 """) 19560 _flimage_enable_tiff()
19561 19562
19563 -def flimage_enable_xbm():
19564 """ flimage_enable_xbm() 19565 """ 19566 19567 _flimage_enable_xbm = cfuncproto( 19568 load_so_libflimage(), "flimage_enable_xbm", 19569 None, [], 19570 """void flimage_enable_xbm() 19571 """) 19572 _flimage_enable_xbm()
19573 19574
19575 -def flimage_enable_xpm():
19576 """ flimage_enable_xpm() 19577 """ 19578 19579 _flimage_enable_xpm = cfuncproto( 19580 load_so_libflimage(), "flimage_enable_xpm", 19581 None, [], 19582 """void flimage_enable_xpm() 19583 """) 19584 _flimage_enable_xpm()
19585 19586
19587 -def flimage_enable_xwd():
19588 """ flimage_enable_xwd() 19589 """ 19590 19591 _flimage_enable_xwd = cfuncproto( 19592 load_so_libflimage(), "flimage_enable_xwd", 19593 None, [], 19594 """void flimage_enable_xwd() 19595 """) 19596 _flimage_enable_xwd()
19597 19598
19599 -def flimage_free_ci(pImage):
19600 """ flimage_free_ci(pImage) 19601 """ 19602 19603 _flimage_free_ci = cfuncproto( 19604 load_so_libflimage(), "flimage_free_ci", 19605 None, [cty.POINTER(FL_IMAGE)], 19606 """void flimage_free_ci(FL_IMAGE * p1) 19607 """) 19608 keep_elem_refs(pImage) 19609 _flimage_free_ci(pImage)
19610 19611
19612 -def flimage_free_gray(pImage):
19613 """ flimage_free_gray(pImage) 19614 """ 19615 19616 _flimage_free_gray = cfuncproto( 19617 load_so_libflimage(), "flimage_free_gray", 19618 None, [cty.POINTER(FL_IMAGE)], 19619 """void flimage_free_gray(FL_IMAGE * p1) 19620 """) 19621 keep_elem_refs(pImage) 19622 _flimage_free_gray(pImage)
19623 19624
19625 -def flimage_free_linearlut(pImage):
19626 """ flimage_free_linearlut(pImage) 19627 """ 19628 19629 _flimage_free_linearlut = cfuncproto( 19630 load_so_libflimage(), "flimage_free_linearlut", 19631 None, [cty.POINTER(FL_IMAGE)], 19632 """void flimage_free_linearlut(FL_IMAGE * p1) 19633 """) 19634 keep_elem_refs(pImage) 19635 _flimage_free_linearlut(pImage)
19636 19637
19638 -def flimage_free_rgb(pImage):
19639 """ flimage_free_rgb(pImage) 19640 """ 19641 19642 _flimage_free_rgb = cfuncproto( 19643 load_so_libflimage(), "flimage_free_rgb", 19644 None, [cty.POINTER(FL_IMAGE)], 19645 """void flimage_free_rgb(FL_IMAGE * p1) 19646 """) 19647 keep_elem_refs(pImage) 19648 _flimage_free_rgb(pImage)
19649 19650
19651 -def flimage_freemem(pImage):
19652 """ flimage_freemem(pImage) 19653 """ 19654 19655 _flimage_freemem = cfuncproto( 19656 load_so_libflimage(), "flimage_freemem", 19657 None, [cty.POINTER(FL_IMAGE)], 19658 """void flimage_freemem(FL_IMAGE * p1) 19659 """) 19660 keep_elem_refs(pImage) 19661 _flimage_freemem(pImage)
19662 19663
19664 -def flimage_get_closest_color_from_map(pImage, p2):
19665 """ flimage_get_closest_color_from_map(pImage, p2) -> num. 19666 """ 19667 19668 _flimage_get_closest_color_from_map = cfuncproto( 19669 load_so_libflimage(), "flimage_get_closest_color_from_map", 19670 cty.c_int, [cty.POINTER(FL_IMAGE), cty.c_uint], 19671 """int flimage_get_closest_color_from_map(FL_IMAGE * p1, 19672 unsigned int p2) 19673 """) 19674 uip2 = convert_to_uint(p2) 19675 keep_elem_refs(pImage, p2, uip2) 19676 retval = _flimage_get_closest_color_from_map(pImage, uip2) 19677 return retval
19678 19679
19680 -def flimage_get_linearlut(pImage):
19681 """ flimage_get_linearlut(pImage) -> num. 19682 """ 19683 19684 _flimage_get_linearlut = cfuncproto( 19685 load_so_libflimage(), "flimage_get_linearlut", 19686 cty.c_int, [cty.POINTER(FL_IMAGE)], 19687 """int flimage_get_linearlut(FL_IMAGE * p1) 19688 """) 19689 keep_elem_refs(pImage) 19690 retval = _flimage_get_linearlut(pImage) 19691 return retval
19692 19693
19694 -def flimage_invalidate_pixels(pImage):
19695 """ flimage_invalidate_pixels(pImage) 19696 """ 19697 19698 _flimage_invalidate_pixels = cfuncproto( 19699 load_so_libflimage(), "flimage_invalidate_pixels", 19700 None, [cty.POINTER(FL_IMAGE)], 19701 """void flimage_invalidate_pixels(FL_IMAGE * p1) 19702 """) 19703 keep_elem_refs(pImage) 19704 _flimage_invalidate_pixels(pImage)
19705 19706
19707 -def flimage_open(filename):
19708 """ flimage_open(filename) -> pImage 19709 """ 19710 19711 _flimage_open = cfuncproto( 19712 load_so_libflimage(), "flimage_open", 19713 cty.POINTER(FL_IMAGE), [STRING], 19714 """FL_IMAGE * flimage_open(const char * p1) 19715 """) 19716 sfilename = convert_to_string(filename) 19717 keep_elem_refs(filename, sfilename) 19718 retval = _flimage_open(sfilename) 19719 return retval
19720 19721
19722 -def flimage_read_annotation(pImage):
19723 """ flimage_read_annotation(pImage) -> num. 19724 """ 19725 19726 _flimage_read_annotation = cfuncproto( 19727 load_so_libflimage(), "flimage_read_annotation", 19728 cty.c_int, [cty.POINTER(FL_IMAGE)], 19729 """int flimage_read_annotation(FL_IMAGE * p1) 19730 """) 19731 keep_elem_refs(pImage) 19732 retval = _flimage_read_annotation(pImage) 19733 return retval
19734 19735
19736 -def flimage_replace_image(pImage, w, h, r, g, b):
19737 """ flimage_replace_image(pImage, w, h, r, g, b) 19738 """ 19739 19740 _flimage_replace_image = cfuncproto( 19741 load_so_libflimage(), "flimage_replace_image", 19742 None, [cty.POINTER(FL_IMAGE), cty.c_int, cty.c_int, cty.c_void_p, 19743 cty.c_void_p, cty.c_void_p], 19744 """void flimage_replace_image(FL_IMAGE * p1, int p2, int p3, 19745 void * p4, void * p5, void * p6) 19746 """) 19747 iw = convert_to_int(w) 19748 ih = convert_to_int(h) 19749 pr = cty.cast(r, cty.c_void_p) 19750 pg = cty.cast(g, cty.c_void_p) 19751 pb = cty.cast(b, cty.c_void_p) 19752 keep_elem_refs(pImage, w, h, r, g, b, iw, ih, pr, pg, pb) 19753 _flimage_replace_image(pImage, iw, ih, pr, pg, pb)
19754 19755
19756 -def flimage_swapbuffer(pImage):
19757 """ flimage_swapbuffer(pImage) -> num. 19758 """ 19759 19760 _flimage_swapbuffer = cfuncproto( 19761 load_so_libflimage(), "flimage_swapbuffer", 19762 cty.c_int, [cty.POINTER(FL_IMAGE)], 19763 """int flimage_swapbuffer(FL_IMAGE * p1) 19764 """) 19765 keep_elem_refs(pImage) 19766 retval = _flimage_swapbuffer(pImage) 19767 return retval
19768 19769
19770 -def flimage_to_ximage(pImage, win, pXWindowAttributes):
19771 """ flimage_to_ximage(pImage, win, pXWindowAttributes) -> num. 19772 """ 19773 19774 _flimage_to_ximage = cfuncproto( 19775 load_so_libflimage(), "flimage_to_ximage", 19776 cty.c_int, [cty.POINTER(FL_IMAGE), FL_WINDOW, 19777 cty.POINTER(XWindowAttributes)], 19778 """int flimage_to_ximage(FL_IMAGE * p1, FL_WINDOW p2, 19779 XWindowAttributes * p3) 19780 """) 19781 ulwin = convert_to_Window(win) 19782 keep_elem_refs(pImage, win, pXWindowAttributes, ulwin) 19783 retval = _flimage_to_ximage(pImage, ulwin, pXWindowAttributes) 19784 return retval
19785 19786
19787 -def flimage_write_annotation(pImage):
19788 """ flimage_write_annotation(pImage) -> num. 19789 """ 19790 19791 _flimage_write_annotation = cfuncproto( 19792 load_so_libflimage(), "flimage_write_annotation", 19793 cty.c_int, [cty.POINTER(FL_IMAGE)], 19794 """int flimage_write_annotation(FL_IMAGE * p1) 19795 """) 19796 keep_elem_refs(pImage) 19797 retval = _flimage_write_annotation(pImage) 19798 return retval
19799 19800
19801 -def flps_apply_gamma(p1):
19802 """ flps_apply_gamma(p1) 19803 """ 19804 19805 _flps_apply_gamma = cfuncproto( 19806 load_so_libflimage(), "flps_apply_gamma", 19807 None, [cty.c_float], 19808 """void flps_apply_gamma(float p1) 19809 """) 19810 fp1 = convert_to_float(p1) 19811 keep_elem_refs(p1, fp1) 19812 _flps_apply_gamma(fp1)
19813 19814
19815 -def flps_arc(fill, x, y, r, t1, t2, colr):
19816 """ flps_arc(p1, p2, p3, p4, p5, p6, p7) 19817 """ 19818 19819 _flps_arc = cfuncproto( 19820 load_so_libflimage(), "flps_arc", 19821 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 19822 cty.c_int, cty.c_long], 19823 """void flps_arc(int p1, int p2, int p3, int p4, int p5, int p6, 19824 long int p7) 19825 """) 19826 ifill = convert_to_int(fill) 19827 ix = convert_to_int(x) 19828 iy = convert_to_int(y) 19829 ir = convert_to_int(r) 19830 it1 = convert_to_int(t1) 19831 it2 = convert_to_int(t2) 19832 lcolr = convert_to_long(colr) 19833 keep_elem_refs(fill, x, y, r, t1, t2, colr, ifill, ix, iy, ir, it1, \ 19834 it2, lcolr) 19835 _flps_arc(ifill, ix, iy, ir, it1, it2, lcolr)
19836 19837
19838 -def flps_circ(fill, x, y, r, colr):
19839 """ flps_circ(fill, x, y, r, colr) 19840 """ 19841 19842 _flps_circ = cfuncproto( 19843 load_so_libflimage(), "flps_circ", 19844 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_long], 19845 """void flps_circ(int p1, int p2, int p3, int p4, long int p5) 19846 """) 19847 ifill = convert_to_int(fill) 19848 ix = convert_to_int(x) 19849 iy = convert_to_int(y) 19850 ir = convert_to_int(r) 19851 lcolr = convert_to_long(colr) 19852 keep_elem_refs(fill, x, y, r, colr, ifill, ix, iy, ir, lcolr) 19853 _flps_circ(fill, x, y, r, colr, ifill, ix, iy, ir, lcolr)
19854 19855
19856 -def flps_color(colr):
19857 """ flps_color(colr) 19858 """ 19859 19860 _flps_color = cfuncproto( 19861 load_so_libflimage(), "flps_color", 19862 None, [cty.c_long], 19863 """void flps_color(long int p1) 19864 """) 19865 lcolr = convert_to_long(colr) 19866 keep_elem_refs(colr, lcolr) 19867 _flps_color(lcolr)
19868 19869
19870 -def flps_draw_box(style, x, y, w, h, colr, bwIn):
19871 """ flps_draw_box(style, x, y, w, h, colr, bwIn) 19872 """ 19873 19874 _flps_draw_box = cfuncproto( 19875 load_so_libflimage(), "flps_draw_box", 19876 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 19877 cty.c_long, cty.c_int], 19878 """void flps_draw_box(int p1, int p2, int p3, int p4, int p5, 19879 long int p6, int p7) 19880 """) 19881 istyle = convert_to_int(style) 19882 ix = convert_to_int(x) 19883 iy = convert_to_int(y) 19884 iw = convert_to_int(w) 19885 ih = convert_to_int(h) 19886 lcolr = convert_to_long(colr) 19887 ibwIn = convert_to_int(bwIn) 19888 keep_elem_refs(style, x, y, w, h, colr, bwIn, istyle, ix, iy, iw, ih, \ 19889 lcolr, ibwIn) 19890 _flps_draw_box(istyle, ix, iy, iw, ih, lcolr, ibwIn)
19891 19892
19893 -def flps_draw_checkbox(boxtype, x, y, w, h, colr, bw):
19894 """ flps_draw_checkbox(boxtype, x, y, w, h, colr, bw) 19895 """ 19896 19897 _flps_draw_checkbox = cfuncproto( 19898 load_so_libflimage(), "flps_draw_checkbox", 19899 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 19900 cty.c_long, cty.c_int], 19901 """void flps_draw_checkbox(int p1, int p2, int p3, int p4, 19902 int p5, long int p6, int p7) 19903 """) 19904 iboxtype = convert_to_int(boxtype) 19905 ix = convert_to_int(x) 19906 iy = convert_to_int(y) 19907 iw = convert_to_int(w) 19908 ih = convert_to_int(h) 19909 lcolr = convert_to_long(colr) 19910 ibw = convert_to_int(bw) 19911 keep_elem_refs(boxtype, x, y, w, h, colr, bw, iboxtype, ix, iy, iw, ih, \ 19912 lcolr, ibw) 19913 _flps_draw_checkbox(iboxtype, ix, iy, iw, ih, lcolr, ibw)
19914 19915
19916 -def flps_draw_frame(style, x, y, w, h, colr, bw):
19917 """ flps_draw_frame(style, x, y, w, h, colr, bw) 19918 """ 19919 19920 _flps_draw_frame = cfuncproto( 19921 load_so_libflimage(), "flps_draw_frame", 19922 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 19923 cty.c_long, cty.c_int], 19924 """void flps_draw_frame(int p1, int p2, int p3, int p4, int p5, 19925 long int p6, int p7) 19926 """) 19927 istyle = convert_to_int(style) 19928 ix = convert_to_int(x) 19929 iy = convert_to_int(y) 19930 iw = convert_to_int(w) 19931 ih = convert_to_int(h) 19932 lcolr = convert_to_long(colr) 19933 ibw = convert_to_int(bw) 19934 keep_elem_refs(style, x, y, w, h, colr, bw, istyle, ix, iy, iw, ih, \ 19935 lcolr, ibw) 19936 _flps_draw_frame(istyle, ix, iy, iw, ih, lcolr, ibw)
19937 19938
19939 -def flps_draw_symbol(label, x, y, w, h, colr):
19940 """ flps_draw_symbol(label, x, y, w, h, colr) -> num. 19941 """ 19942 19943 _flps_draw_symbol = cfuncproto( 19944 load_so_libflimage(), "flps_draw_symbol", 19945 cty.c_int, [STRING, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 19946 cty.c_long], 19947 """int flps_draw_symbol(const char * p1, int p2, int p3, int p4, 19948 int p5, long int p6) 19949 """) 19950 slabel = convert_to_string(label) 19951 ix = convert_to_int(x) 19952 iy = convert_to_int(y) 19953 iw = convert_to_int(w) 19954 ih = convert_to_int(h) 19955 lcolr = convert_to_long(colr) 19956 keep_elem_refs(label, x, y, w, h, colr, slabel, ix, iy, iw, ih, lcolr) 19957 retval = _flps_draw_symbol(slabel, ix, iy, iw, ih, lcolr) 19958 return retval
19959 19960
19961 -def flps_draw_tbox(style, x, y, w, h, colr, bw):
19962 """ flps_draw_tbox(style, x, y, w, h, colr, bw) 19963 """ 19964 19965 _flps_draw_tbox = cfuncproto( 19966 load_so_libflimage(), "flps_draw_tbox", 19967 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 19968 cty.c_long, cty.c_int], 19969 """void flps_draw_tbox(int p1, int p2, int p3, int p4, int p5, 19970 long int p6, int p7) 19971 """) 19972 istyle = convert_to_int(style) 19973 ix = convert_to_int(x) 19974 iy = convert_to_int(y) 19975 iw = convert_to_int(w) 19976 ih = convert_to_int(h) 19977 lcolr = convert_to_long(colr) 19978 ibw = convert_to_int(bw) 19979 keep_elem_refs(style, x, y, w, h, colr, bw, istyle, ix, iy, iw, ih, lcolr, ibw) 19980 _flps_draw_tbox(istyle, ix, iy, iw, ih, lcolr, ibw)
19981 19982
19983 -def flps_draw_text(align, x, y, w, h, colr, style, size, text):
19984 """ flps_draw_text(align, x, y, w, h, colr, style, size, text) 19985 """ 19986 19987 _flps_draw_text = cfuncproto( 19988 load_so_libflimage(), "flps_draw_text", 19989 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 19990 cty.c_long, cty.c_int, cty.c_int, STRING], 19991 """void flps_draw_text(int p1, int p2, int p3, int p4, int p5, 19992 long int p6, int p7, int p8, const char * p9) 19993 """) 19994 ialign = convert_to_int(align) 19995 ix = convert_to_int(x) 19996 iy = convert_to_int(y) 19997 iw = convert_to_int(w) 19998 ih = convert_to_int(h) 19999 lcolr = convert_to_long(colr) 20000 istyle = convert_to_int(style) 20001 isize = convert_to_int(size) 20002 stext = convert_to_string(text) 20003 keep_elem_refs(align, x, y, w, h, colr, style, size, text, ialign, \ 20004 ix, iy, iw, ih, lcolr, istyle, isize, stext) 20005 _flps_draw_text(ialign, ix, iy, iw, ih, lcolr, istyle, isize, stext)
20006 20007
20008 -def flps_draw_text_beside(align, x, y, w, h, colr, style, size, text):
20009 """ flps_draw_text_beside(align, x, y, w, h, colr, style, size, text) 20010 """ 20011 20012 _flps_draw_text_beside = cfuncproto( 20013 load_so_libflimage(), "flps_draw_text_beside", 20014 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 20015 cty.c_long, cty.c_int, cty.c_int, STRING], 20016 """void flps_draw_text_beside(int p1, int p2, int p3, int p4, 20017 int p5, long int p6, int p7, int p8, const char * p9) 20018 """) 20019 ialign = convert_to_int(align) 20020 ix = convert_to_int(x) 20021 iy = convert_to_int(y) 20022 iw = convert_to_int(w) 20023 ih = convert_to_int(h) 20024 lcolr = convert_to_long(colr) 20025 istyle = convert_to_int(style) 20026 isize = convert_to_int(size) 20027 stext = convert_to_string(text) 20028 keep_elem_refs(align, x, y, w, h, colr, style, size, text, ialign, \ 20029 ix, iy, iw, ih, lcolr, istyle, isize, stext) 20030 _flps_draw_text_beside(ialign, ix, iy, iw, ih, lcolr, istyle, isize, \ 20031 stext)
20032 20033
20034 -def flps_emit_header(title, npages, xi, yi, xf, yf):
20035 """ flps_emit_header(title, npages, xi, yi, xf, yf) 20036 """ 20037 20038 _flps_emit_header = cfuncproto( 20039 load_so_libflimage(), "flps_emit_header", 20040 None, [STRING, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 20041 cty.c_int], 20042 """void flps_emit_header(const char * p1, int p2, int p3, 20043 int p4, int p5, int p6) 20044 """) 20045 stitle = convert_to_string(title) 20046 inpages = convert_to_int(npages) 20047 ixi = convert_to_int(xi) 20048 iyi = convert_to_int(yi) 20049 ixf = convert_to_int(xf) 20050 iyf = convert_to_int(yf) 20051 keep_elem_refs(title, npages, xi, yi, xf, yf, stitle, inpages, ixi, \ 20052 iyi, ixf, iyf) 20053 _flps_emit_header(stitle, inpages, ixi, iyi, ixf, iyf)
20054 20055
20056 -def flps_emit_prolog():
20057 """ flps_emit_prolog() 20058 """ 20059 20060 _flps_emit_prolog = cfuncproto( 20061 load_so_libflimage(), "flps_emit_prolog", 20062 None, [], 20063 """void flps_emit_prolog() 20064 """) 20065 _flps_emit_prolog()
20066 20067
20068 -def flps_get_gray255(colr):
20069 """ flps_get_gray255(colr) -> num. 20070 """ 20071 20072 _flps_get_gray255 = cfuncproto( 20073 load_so_libflimage(), "flps_get_gray255", 20074 cty.c_int, [cty.c_long], 20075 """int flps_get_gray255(long int p1) 20076 """) 20077 lcolr = convert_to_long(colr) 20078 keep_elem_refs(colr, lcolr) 20079 retval = _flps_get_gray255(lcolr) 20080 return retval
20081 20082
20083 -def flps_get_linestyle():
20084 """ flps_get_linestyle() -> num. 20085 """ 20086 20087 _flps_get_linestyle = cfuncproto( 20088 load_so_libflimage(), "flps_get_linestyle", 20089 cty.c_int, [], 20090 """int flps_get_linestyle() 20091 """) 20092 retval = _flps_get_linestyle() 20093 return retval
20094 20095
20096 -def flps_get_linewidth():
20097 """ flps_get_linewidth() -> width num. 20098 """ 20099 20100 _flps_get_linewidth = cfuncproto( 20101 load_so_libflimage(), "flps_get_linewidth", 20102 cty.c_int, [], 20103 """int flps_get_linewidth() 20104 """) 20105 retval = _flps_get_linewidth() 20106 return retval
20107 20108
20109 -def flps_get_namedcolor(colrname):
20110 """ flps_get_namedcolor(colrname) -> num. 20111 """ 20112 20113 _flps_get_namedcolor = cfuncproto( 20114 load_so_libflimage(), "flps_get_namedcolor", 20115 cty.c_int, [STRING], 20116 """int flps_get_namedcolor(const char * p1) 20117 """) 20118 scolrname = convert_to_string(colrname) 20119 keep_elem_refs(colrname, scolrname) 20120 retval = _flps_get_namedcolor(scolrname) 20121 return retval
20122 20123
20124 -def flps_invalidate_color_cache():
20125 """ flps_invalidate_color_cache() 20126 """ 20127 20128 _flps_invalidate_color_cache = cfuncproto( 20129 load_so_libflimage(), "flps_invalidate_color_cache", 20130 None, [], 20131 """void flps_invalidate_color_cache() 20132 """) 20133 _flps_invalidate_color_cache()
20134 20135
20136 -def flps_invalidate_font_cache():
20137 """ flps_invalidate_font_cache() 20138 """ 20139 20140 _flps_invalidate_font_cache = cfuncproto( 20141 load_so_libflimage(), "flps_invalidate_font_cache", 20142 None, [], 20143 """void flps_invalidate_font_cache() 20144 """) 20145 _flps_invalidate_font_cache()
20146 20147
20148 -def flps_invalidate_linewidth_cache():
20149 """ flps_invalidate_linewidth_cache() 20150 """ 20151 20152 _flps_invalidate_linewidth_cache = cfuncproto( 20153 load_so_libflimage(), "flps_invalidate_linewidth_cache", 20154 None, [], 20155 """void flps_invalidate_linewidth_cache() 20156 """) 20157 _flps_invalidate_linewidth_cache()
20158 20159
20160 -def flps_invalidate_symbol_cache():
20161 """ flps_invalidate_symbol_cache() 20162 """ 20163 20164 _flps_invalidate_symbol_cache = cfuncproto( 20165 load_so_libflimage(), "flps_invalidate_symbol_cache", 20166 None, [], 20167 """void flps_invalidate_symbol_cache() 20168 """) 20169 _flps_invalidate_symbol_cache()
20170 20171
20172 -def flps_line(xi, yi, xf, yf, colr):
20173 """ flps_line(xi, yi, xf, yf, colr) 20174 """ 20175 20176 _flps_line = cfuncproto( 20177 load_so_libflimage(), "flps_line", 20178 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_long], 20179 """void flps_line(int p1, int p2, int p3, int p4, long int p5) 20180 """) 20181 ixi = convert_to_int(xi) 20182 iyi = convert_to_int(yi) 20183 ixf = convert_to_int(xf) 20184 iyf = convert_to_int(yf) 20185 lcolr = convert_to_long(colr) 20186 keep_elem_refs(xi, yi, xf, yf, colr, ixi, iyi, ixf, iyf, lcolr) 20187 _flps_line(ixi, iyi, ixf, iyf, lcolr)
20188 20189
20190 -def flps_lines(pPoint, num, colr):
20191 """ flps_lines(pPoint, num, colr) 20192 """ 20193 20194 _flps_lines = cfuncproto( 20195 load_so_libflimage(), "flps_lines", 20196 None, [cty.POINTER(FL_POINT), cty.c_int, cty.c_long], 20197 """void flps_lines(FL_POINT * p1, int p2, long int p3) 20198 """) 20199 inum = convert_to_int(num) 20200 lcolr = convert_to_long(colr) 20201 keep_elem_refs(pPoint, num, colr, inum, lcolr) 20202 _flps_lines(pPoint, inum, lcolr)
20203 20204
20205 -def flps_linestyle(linestyle):
20206 """ flps_linestyle(linestyle) 20207 """ 20208 20209 _flps_linestyle = cfuncproto( 20210 load_so_libflimage(), "flps_linestyle", 20211 None, [cty.c_int], 20212 """void flps_linestyle(int p1) 20213 """) 20214 check_admitted_listvalues(linestyle, LINE_list) 20215 ilinestyle = convert_to_int(linestyle) 20216 keep_elem_refs(linestyle, ilinestyle) 20217 _flps_linestyle(ilinestyle)
20218 20219
20220 -def flps_linewidth(linewidth):
20221 """ flps_linewidth(linewidth) 20222 """ 20223 20224 _flps_linewidth = cfuncproto( 20225 load_so_libflimage(), "flps_linewidth", 20226 None, [cty.c_int], 20227 """void flps_linewidth(int p1) 20228 """) 20229 ilinewidth = convert_to_int(linewidth) 20230 keep_elem_refs(linewidth, ilinewidth) 20231 _flps_linewidth(ilinewidth)
20232 20233
20234 -def flps_log(text):
20235 """ flps_log(text) 20236 """ 20237 20238 _flps_log = cfuncproto( 20239 load_so_libflimage(), "flps_log", 20240 None, [STRING], 20241 """void flps_log(const char * p1) 20242 """) 20243 stext = convert_to_string(text) 20244 keep_elem_refs(text, stext) 20245 _flps_log(stext)
20246 20247
20248 -def flps_output(fmt):
20249 """ flps_output(fmt) 20250 """ 20251 20252 _flps_output = cfuncproto( 20253 load_so_libflimage(), "flps_output", 20254 None, [STRING], 20255 """void flps_output(const char * p1) 20256 """) 20257 sfmt = convert_to_string(fmt) 20258 keep_elem_refs(fmt, sfmt) 20259 _flps_output(sfmt)
20260 20261
20262 -def flps_oval(fill, x, y, w, h, colr):
20263 """ flps_oval(fill, x, y, w, h, colr) 20264 """ 20265 20266 _flps_oval = cfuncproto( 20267 load_so_libflimage(), "flps_oval", 20268 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 20269 cty.c_long], 20270 """void flps_oval(int p1, int p2, int p3, int p4, int p5, 20271 long int p6) 20272 """) 20273 ifill = convert_to_int(fill) 20274 ix = convert_to_int(x) 20275 iy = convert_to_int(y) 20276 iw = convert_to_int(w) 20277 ih = convert_to_int(h) 20278 lcolr = convert_to_long(colr) 20279 keep_elem_refs(fill, x, y, w, h, colr, ifill, ix, iy, iw, ih, lcolr) 20280 _flps_oval(ifill, ix, iy, iw, ih, lcolr)
20281 20282
20283 -def flps_pieslice(fill, x, y, w, h, t1, t2, colr):
20284 """ flps_pieslice(fill, x, y, w, h, t1, t2, colr) 20285 """ 20286 20287 _flps_pieslice = cfuncproto( 20288 load_so_libflimage(), "flps_pieslice", 20289 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 20290 cty.c_int, cty.c_int, cty.c_long], 20291 """void flps_pieslice(int p1, int p2, int p3, int p4, int p5, 20292 int p6, int p7, long int p8) 20293 """) 20294 ifill = convert_to_int(fill) 20295 ix = convert_to_int(x) 20296 iy = convert_to_int(y) 20297 iw = convert_to_int(w) 20298 ih = convert_to_int(h) 20299 it1 = convert_to_int(t1) 20300 it2 = convert_to_int(t2) 20301 lcolr = convert_to_long(colr) 20302 keep_elem_refs(fill, x, y, w, h, t1, t2, colr, ifill, ix, iy, iw, \ 20303 ih, it1, it2, lcolr) 20304 _flps_pieslice(ifill, ix, iy, iw, ih, it1, it2, lcolr)
20305 20306
20307 -def flps_poly(fill, pPoint, num, colr):
20308 """ flps_poly(fill, pPoint, num, colr) 20309 """ 20310 20311 _flps_poly = cfuncproto( 20312 load_so_libflimage(), "flps_poly", 20313 None, [cty.c_int, cty.POINTER(FL_POINT), cty.c_int, cty.c_long], 20314 """void flps_poly(int p1, FL_POINT * p2, int p3, long int p4) 20315 """) 20316 ifill = convert_to_int(fill) 20317 inum = convert_to_int(num) 20318 lcolr = convert_to_long(colr) 20319 keep_elem_refs(fill, pPoint, num, colr, ifill, inum, lcolr) 20320 _flps_poly(ifill, pPoint, inum, lcolr)
20321 20322
20323 -def flps_rectangle(fill, x, y, w, h, colr):
20324 """ flps_rectangle(fill, x, y, w, h, colr) 20325 """ 20326 20327 _flps_rectangle = cfuncproto( 20328 load_so_libflimage(), "flps_rectangle", 20329 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 20330 cty.c_long], 20331 """void flps_rectangle(int p1, int p2, int p3, int p4, int p5, 20332 long int p6) 20333 """) 20334 ifill = convert_to_int(fill) 20335 ix = convert_to_int(x) 20336 iy = convert_to_int(y) 20337 iw = convert_to_int(w) 20338 ih = convert_to_int(h) 20339 lcolr = convert_to_long(colr) 20340 keep_elem_refs(fill, x, y, w, h, colr, ifill, ix, iy, iw, ih, lcolr) 20341 _flps_rectangle(ifill, ix, iy, iw, ih, lcolr)
20342 20343
20344 -def flps_reset_cache():
20345 """ flps_reset_cache() 20346 """ 20347 20348 _flps_reset_cache = cfuncproto( 20349 load_so_libflimage(), "flps_reset_cache", 20350 None, [], 20351 """void flps_reset_cache() 20352 """) 20353 _flps_reset_cache()
20354 20355
20356 -def flps_reset_linewidth():
20357 """ flps_reset_linewidth() 20358 """ 20359 20360 _flps_reset_linewidth = cfuncproto( 20361 load_so_libflimage(), "flps_reset_linewidth", 20362 None, [], 20363 """void flps_reset_linewidth() 20364 """) 20365 _flps_reset_linewidth()
20366 20367
20368 -def flps_restore_flps():
20369 """ flps_restore_flps() 20370 """ 20371 20372 _flps_restore_flps = cfuncproto( 20373 load_so_libflimage(), "flps_restore_flps", 20374 None, [], 20375 """void flps_restore_flps() 20376 """) 20377 _flps_restore_flps()
20378 20379
20380 -def flps_rgbcolor(r, g, b):
20381 """ flps_rgbcolor(r, g, b) 20382 """ 20383 20384 _flps_rgbcolor = cfuncproto( 20385 load_so_libflimage(), "flps_rgbcolor", 20386 None, [cty.c_int, cty.c_int, cty.c_int], 20387 """void flps_rgbcolor(int p1, int p2, int p3) 20388 """) 20389 ir = convert_to_int(r) 20390 ig = convert_to_int(g) 20391 ib = convert_to_int(b) 20392 keep_elem_refs(r, g, b, ir, ig, ib) 20393 _flps_rgbcolor(ir, ig, ib)
20394 20395
20396 -def flps_roundrectangle(fill, x, y, w, h, colr):
20397 """ flps_roundrectangle(fill, x, y, w, h, colr) 20398 """ 20399 20400 _flps_roundrectangle = cfuncproto( 20401 load_so_libflimage(), "flps_roundrectangle", 20402 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int, 20403 cty.c_long], 20404 """void flps_roundrectangle(int p1, int p2, int p3, int p4, 20405 int p5, long int p6) 20406 """) 20407 ifill = convert_to_int(fill) 20408 ix = convert_to_int(x) 20409 iy = convert_to_int(y) 20410 iw = convert_to_int(w) 20411 ih = convert_to_int(h) 20412 lcolr = convert_to_long(colr) 20413 keep_elem_refs(fill, x, y, w, h, colr, ifill, ix, iy, iw, ih, lcolr) 20414 _flps_roundrectangle(ifill, ix, iy, iw, ih, lcolr)
20415 20416
20417 -def flps_set_clipping(x, y, w, h):
20418 """ flps_set_clipping(x, y, w, h) 20419 """ 20420 20421 _flps_set_clipping = cfuncproto( 20422 load_so_libflimage(), "flps_set_clipping", 20423 None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int], 20424 """void flps_set_clipping(int p1, int p2, int p3, int p4) 20425 """) 20426 ix = convert_to_int(x) 20427 iy = convert_to_int(y) 20428 iw = convert_to_int(w) 20429 ih = convert_to_int(h) 20430 keep_elem_refs(x, y, w, h, ix, iy, iw, ih) 20431 _flps_set_clipping(ix, iy, iw, ih)
20432 20433
20434 -def flps_set_font(style, size):
20435 """ flps_set_font(style, size) 20436 """ 20437 20438 _flps_set_font = cfuncproto( 20439 load_so_libflimage(), "flps_set_font", 20440 None, [cty.c_int, cty.c_int], 20441 """void flps_set_font(int p1, int p2) 20442 """) 20443 check_admitted_listvalues(style, TEXTSTYLE_list) 20444 istyle = convert_to_int(style) 20445 isize = convert_to_int(size) 20446 keep_elem_refs(style, size, istyle, isize) 20447 _flps_set_font(istyle, isize)
20448 20449
20450 -def flps_unset_clipping():
20451 """ flps_unset_clipping() 20452 """ 20453 20454 _flps_unset_clipping = cfuncproto( 20455 load_so_libflimage(), "flps_unset_clipping", 20456 None, [], 20457 """void flps_unset_clipping() 20458 """) 20459 _flps_unset_clipping()
20460